feat: implement AI legal assistant system MVP

Core modules:
- Laws: CRUD, search, AI-powered QA
- Analysis: legal research and case management
- Contracts: lifecycle management with templates
- Signatures: electronic signature workflow

Infrastructure:
- FastAPI + SQLite + async SQLAlchemy
- Docker deployment support
- 54 unit tests passing

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
rootandClaude Opus 4.7 committed 2026-05-01 03:34:44 +08:00
1 parent 830b33c4b3
commit 656f596d7e
51 files changed
+3690

No files matched your search

+1
View File
@@ -0,0 +1 @@
# Schemas package
+87
View File
@@ -0,0 +1,87 @@
"""Schemas for Analysis module."""
from datetime import date, datetime
from typing import List, Optional
from enum import Enum
from pydantic import BaseModel, Field
class AnalysisStatusEnum(str, Enum):
DRAFT = "draft"
IN_PROGRESS = "in_progress"
COMPLETED = "completed"
class LegalAnalysisBase(BaseModel):
"""Base schema for LegalAnalysis."""
title: str = Field(..., max_length=200)
case_description: str
class LegalAnalysisCreate(LegalAnalysisBase):
"""Schema for creating a legal analysis."""
legal_basis: Optional[dict] = None
class LegalAnalysisUpdate(BaseModel):
"""Schema for updating a legal analysis."""
title: Optional[str] = Field(None, max_length=200)
case_description: Optional[str] = None
legal_basis: Optional[dict] = None
analysis_content: Optional[str] = None
conclusion: Optional[str] = None
status: Optional[AnalysisStatusEnum] = None
class LegalAnalysisResponse(LegalAnalysisBase):
"""Schema for legal analysis response."""
id: int
user_id: int
legal_basis: Optional[dict] = None
analysis_content: Optional[str] = None
conclusion: Optional[str] = None
status: AnalysisStatusEnum
created_at: datetime
updated_at: datetime
class Config:
from_attributes = True
class CaseBase(BaseModel):
"""Base schema for Case."""
title: str = Field(..., max_length=200)
case_number: Optional[str] = Field(None, max_length=50)
court: Optional[str] = Field(None, max_length=100)
case_type: Optional[str] = Field(None, max_length=100)
judgment_date: Optional[date] = None
facts: Optional[str] = None
judgment: Optional[str] = None
reasoning: Optional[str] = None
class CaseCreate(CaseBase):
"""Schema for creating a case."""
pass
class CaseResponse(CaseBase):
"""Schema for case response."""
id: int
created_at: datetime
class Config:
from_attributes = True
class GenerateAnalysisRequest(BaseModel):
"""Schema for generating analysis with AI."""
case_description: str
relevant_laws: Optional[List[str]] = None
class GenerateAnalysisResponse(BaseModel):
"""Schema for generated analysis response."""
analysis_content: str
legal_basis: List[str] = []
conclusion: str
+112
View File
@@ -0,0 +1,112 @@
"""Schemas for Contract module."""
from datetime import date, datetime
from typing import Optional
from enum import Enum
from pydantic import BaseModel, Field
class ContractStatusEnum(str, Enum):
DRAFT = "draft"
PENDING_APPROVAL = "pending_approval"
APPROVED = "approved"
PENDING_SIGNATURE = "pending_signature"
SIGNED = "signed"
ARCHIVED = "archived"
REJECTED = "rejected"
class ContractBase(BaseModel):
"""Base schema for Contract."""
title: str = Field(..., max_length=200)
party_a: str = Field(..., max_length=100)
party_b: str = Field(..., max_length=100)
content: str
contract_number: Optional[str] = Field(None, max_length=50)
effective_date: Optional[date] = None
expiry_date: Optional[date] = None
class ContractCreate(ContractBase):
"""Schema for creating a contract."""
template_id: Optional[int] = None
class ContractUpdate(BaseModel):
"""Schema for updating a contract."""
title: Optional[str] = Field(None, max_length=200)
party_a: Optional[str] = Field(None, max_length=100)
party_b: Optional[str] = Field(None, max_length=100)
content: Optional[str] = None
contract_number: Optional[str] = Field(None, max_length=50)
effective_date: Optional[date] = None
expiry_date: Optional[date] = None
status: Optional[ContractStatusEnum] = None
class ContractResponse(ContractBase):
"""Schema for contract response."""
id: int
template_id: Optional[int] = None
status: ContractStatusEnum
file_path: Optional[str] = None
created_by: int
created_at: datetime
updated_at: datetime
class Config:
from_attributes = True
class ContractTemplateBase(BaseModel):
"""Base schema for ContractTemplate."""
name: str = Field(..., max_length=100)
content: str
contract_type: Optional[str] = Field(None, max_length=50)
class ContractTemplateCreate(ContractTemplateBase):
"""Schema for creating a contract template."""
pass
class ContractTemplateResponse(ContractTemplateBase):
"""Schema for contract template response."""
id: int
created_by: int
created_at: datetime
class Config:
from_attributes = True
class ApprovalRequest(BaseModel):
"""Schema for approval request."""
comment: Optional[str] = None
class ApprovalResponse(BaseModel):
"""Schema for approval response."""
id: int
contract_id: int
approver_id: int
status: ContractStatusEnum
comment: Optional[str] = None
created_at: datetime
approved_at: Optional[datetime] = None
class Config:
from_attributes = True
class ContractReviewRequest(BaseModel):
"""Schema for AI contract review request."""
contract_content: str
contract_type: Optional[str] = None
class ContractReviewResponse(BaseModel):
"""Schema for AI contract review response."""
review_result: str
risks: list = []
suggestions: list = []
+107
View File
@@ -0,0 +1,107 @@
"""Schemas for Law module."""
from datetime import date, datetime
from typing import List, Optional
from enum import Enum
from pydantic import BaseModel, Field
class LawTypeEnum(str, Enum):
LAW = "law"
REGULATION = "regulation"
RULE = "rule"
JUDICIAL_INTERPRETATION = "judicial_interpretation"
class LawStatusEnum(str, Enum):
EFFECTIVE = "effective"
REVOKED = "revoked"
AMENDED = "amended"
class LawBase(BaseModel):
"""Base schema for Law."""
title: str = Field(..., max_length=200)
law_type: LawTypeEnum
promulgation_date: date
effective_date: date
issuing_authority: str = Field(..., max_length=100)
content: str
status: LawStatusEnum = LawStatusEnum.EFFECTIVE
document_number: Optional[str] = Field(None, max_length=50)
class LawCreate(LawBase):
"""Schema for creating a law."""
pass
class LawUpdate(BaseModel):
"""Schema for updating a law."""
title: Optional[str] = Field(None, max_length=200)
law_type: Optional[LawTypeEnum] = None
promulgation_date: Optional[date] = None
effective_date: Optional[date] = None
status: Optional[LawStatusEnum] = None
issuing_authority: Optional[str] = Field(None, max_length=100)
content: Optional[str] = None
document_number: Optional[str] = Field(None, max_length=50)
class LawArticleBase(BaseModel):
"""Base schema for LawArticle."""
article_number: str = Field(..., max_length=20)
content: str
class LawArticleCreate(LawArticleBase):
"""Schema for creating a law article."""
law_id: int
class LawArticleResponse(LawArticleBase):
"""Schema for law article response."""
id: int
law_id: int
created_at: datetime
class Config:
from_attributes = True
class LawResponse(LawBase):
"""Schema for law response."""
id: int
created_at: datetime
updated_at: datetime
articles: List[LawArticleResponse] = []
class Config:
from_attributes = True
class LawListResponse(BaseModel):
"""Schema for law list response."""
items: List[LawResponse]
total: int
skip: int
limit: int
class LawSearchRequest(BaseModel):
"""Schema for law search request."""
keyword: str = Field(..., min_length=1)
limit: int = Field(10, ge=1, le=50)
class LegalQARequest(BaseModel):
"""Schema for legal QA request."""
question: str = Field(..., min_length=1)
context: Optional[str] = None
class LegalQAResponse(BaseModel):
"""Schema for legal QA response."""
question: str
answer: str
references: List[str] = []
+61
View File
@@ -0,0 +1,61 @@
"""Schemas for Signature module."""
from datetime import datetime
from typing import Optional
from enum import Enum
from pydantic import BaseModel, Field
class SignatureStatusEnum(str, Enum):
PENDING = "pending"
SIGNED = "signed"
REJECTED = "rejected"
EXPIRED = "expired"
class SignatureRequestCreate(BaseModel):
"""Schema for creating a signature request."""
contract_id: int
signer_name: str = Field(..., max_length=100)
signer_email: str = Field(..., max_length=100)
expire_hours: Optional[int] = None
class SignatureRequestResponse(BaseModel):
"""Schema for signature request response."""
id: int
contract_id: int
requester_id: int
signer_name: str
signer_email: str
status: SignatureStatusEnum
token: str
expires_at: datetime
created_at: datetime
class Config:
from_attributes = True
class SignatureSignRequest(BaseModel):
"""Schema for signing a document."""
signature_data: str # Base64 image or coordinates
class SignatureResponse(BaseModel):
"""Schema for signature response."""
id: int
request_id: int
signer_name: str
signed_at: datetime
verification_hash: str
class Config:
from_attributes = True
class SignatureVerifyResponse(BaseModel):
"""Schema for signature verification response."""
valid: bool
signed_at: Optional[datetime] = None
signer_name: Optional[str] = None