Law

#!/usr/bin/env python3
"""Build queryListCase payload from simple CLI args."""

from __future__ import annotations

import argparse
import json


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--keywords", nargs="*", default=[])
    parser.add_argument("--long-text", default="")
    parser.add_argument("--sort-field", default="correlation", choices=["correlation", "time"])
    parser.add_argument("--sort-order", default="desc", choices=["asc", "desc"])
    parser.add_argument("--page-no", type=int, default=1)
    parser.add_argument("--page-size", type=int, default=5)
    parser.add_argument("--court-level", nargs="*", default=[])
    parser.add_argument("--judgement-type", nargs="*", default=[])
    parser.add_argument("--case-year-start", default="")
    parser.add_argument("--case-year-end", default="")
    args = parser.parse_args()

    condition: dict[str, object] = {}
    if args.long_text.strip():
        condition["longText"] = args.long_text.strip()
    elif args.keywords:
        condition["keywordArr"] = args.keywords

    if args.court_level:
        condition["courtLevelArr"] = args.court_level
    if args.judgement_type:
        condition["judgementTypeArr"] = args.judgement_type
    if args.case_year_start:
        condition["caseYearStart"] = args.case_year_start
    if args.case_year_end:
        condition["caseYearEnd"] = args.case_year_end

    payload = {
        "pageNo": args.page_no,
        "pageSize": args.page_size,
        "sortField": args.sort_field,
        "sortOrder": args.sort_order,
        "condition": condition,
    }
    print(json.dumps(payload, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Build queryListLaw payload from simple CLI args."""

from __future__ import annotations

import argparse
import json


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--keywords", nargs="+", required=True)
    parser.add_argument("--field-name", default="title", choices=["title", "semantic"])
    parser.add_argument("--sort-field", default="correlation")
    parser.add_argument("--sort-order", default="desc", choices=["asc", "desc"])
    parser.add_argument("--page-no", type=int, default=1)
    parser.add_argument("--page-size", type=int, default=5)
    args = parser.parse_args()

    payload = {
        "pageNo": args.page_no,
        "pageSize": args.page_size,
        "sortField": args.sort_field,
        "sortOrder": args.sort_order,
        "condition": {
            "keywords": args.keywords,
            "fieldName": args.field_name,
        },
    }
    print(json.dumps(payload, ensure_ascii=False))


if __name__ == "__main__":
    main()

param(
    [Parameter(Mandatory = $true)]
    [string]$InputMarkdown,
    [Parameter(Mandatory = $true)]
    [string]$OutputDocx
)

if (!(Test-Path $InputMarkdown)) {
    Write-Error "Input markdown not found: $InputMarkdown"
    exit 1
}

$converter = Get-Command markdown_to_docx_converter -ErrorAction SilentlyContinue
if ($converter) {
    & markdown_to_docx_converter --input "$InputMarkdown" --output "$OutputDocx"
    if ($LASTEXITCODE -eq 0) {
        Write-Output "OK: $OutputDocx"
        exit 0
    }
}

$pandoc = Get-Command pandoc -ErrorAction SilentlyContinue
if ($pandoc) {
    & pandoc "$InputMarkdown" -o "$OutputDocx"
    if ($LASTEXITCODE -eq 0) {
        Write-Output "OK: $OutputDocx"
        exit 0
    }
}

Write-Error "No available converter. Install markdown_to_docx_converter or pandoc."
exit 2

#!/usr/bin/env python3
"""Extract readable plain text from a .docx template without external deps."""

from __future__ import annotations

import argparse
import json
from pathlib import Path
import xml.etree.ElementTree as ET
import zipfile


W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
NS = {"w": W_NS}


def _paragraph_to_text(p: ET.Element) -> str:
    chunks: list[str] = []
    for node in p.iter():
        tag = node.tag
        if tag == f"{{{W_NS}}}t":
            chunks.append(node.text or "")
        elif tag == f"{{{W_NS}}}tab":
            chunks.append("\t")
        elif tag in {f"{{{W_NS}}}br", f"{{{W_NS}}}cr"}:
            chunks.append("\n")
    return "".join(chunks).strip()


def extract_docx_text(docx_path: Path) -> str:
    with zipfile.ZipFile(docx_path, "r") as zf:
        with zf.open("word/document.xml") as f:
            root = ET.parse(f).getroot()

    lines: list[str] = []
    for p in root.findall(".//w:p", NS):
        txt = _paragraph_to_text(p)
        if txt:
            lines.append(txt)
    return "\n".join(lines)


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--input", required=True, help="Input .docx path")
    parser.add_argument("--output", help="Output .txt path (optional)")
    parser.add_argument("--max-lines", type=int, default=0, help="Trim output to first N lines")
    args = parser.parse_args()

    input_path = Path(args.input)
    if not input_path.exists():
        print(json.dumps({"ok": False, "error": f"File not found: {input_path}"}, ensure_ascii=False))
        raise SystemExit(1)
    if input_path.suffix.lower() != ".docx":
        print(json.dumps({"ok": False, "error": "Input must be a .docx file"}, ensure_ascii=False))
        raise SystemExit(1)

    try:
        text = extract_docx_text(input_path)
    except KeyError:
        print(json.dumps({"ok": False, "error": "Invalid .docx: missing word/document.xml"}, ensure_ascii=False))
        raise SystemExit(1)
    except Exception as exc:
        print(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False))
        raise SystemExit(1)

    lines = text.splitlines()
    if args.max_lines and args.max_lines > 0:
        lines = lines[: args.max_lines]
    final_text = "\n".join(lines)

    if args.output:
        out_path = Path(args.output)
        out_path.parent.mkdir(parents=True, exist_ok=True)
        out_path.write_text(final_text, encoding="utf-8")
        print(json.dumps({"ok": True, "output": str(out_path), "line_count": len(lines)}, ensure_ascii=False))
    else:
        print(final_text)


if __name__ == "__main__":
    main()

"""Search and download SAMR contract templates for legal-copilot."""

from __future__ import annotations

import argparse
import json
import re
import urllib.request
from pathlib import Path


def slugify(name: str) -> str:
    safe = re.sub(r"[\\/:*?\"<>|]+", "_", name).strip()
    safe = re.sub(r"\s+", "_", safe)
    return safe or "template"


def load_catalog(catalog_path: Path) -> dict:
    if not catalog_path.exists():
        raise SystemExit(
            f"Catalog not found: {catalog_path}. Run scripts/import_contract_library.py first."
        )
    return json.loads(catalog_path.read_text(encoding="utf-8"))


def find_candidates(items: list[dict], keyword: str, limit: int = 10) -> list[dict]:
    keyword_norm = keyword.strip().lower()
    if not keyword_norm:
        return items[:limit]

    scored: list[tuple[int, dict]] = []
    for item in items:
        title = str(item.get("title", ""))
        title_norm = title.lower()
        score = 0
        if keyword_norm in title_norm:
            score += 100
        for token in keyword_norm.split():
            if token and token in title_norm:
                score += 10
        if score > 0:
            scored.append((score, item))

    scored.sort(key=lambda x: x[0], reverse=True)
    return [item for _, item in scored[:limit]]


def download_file(url: str, output_path: Path) -> None:
    output_path.parent.mkdir(parents=True, exist_ok=True)
    request = urllib.request.Request(
        url,
        headers={
            "User-Agent": "Mozilla/5.0",
            "Accept": "*/*",
        },
    )
    with urllib.request.urlopen(request, timeout=60) as response:
        output_path.write_bytes(response.read())


def main() -> None:
    parser = argparse.ArgumentParser(description="Fetch SAMR template by id or keyword")
    skill_root = Path(__file__).resolve().parents[1]
    parser.add_argument(
        "--catalog",
        default=str(skill_root / "references" / "samr_contract_templates.json"),
        help="Normalized SAMR catalog path",
    )
    parser.add_argument("--id", help="Template id")
    parser.add_argument("--keyword", help="Keyword search in title")
    parser.add_argument(
        "--type",
        choices=["word", "pdf"],
        default="word",
        help="Download file type",
    )
    parser.add_argument(
        "--out-dir",
        default=str(skill_root / "assets" / "templates" / "official" / "samr"),
        help="Output directory",
    )
    args = parser.parse_args()

    catalog = load_catalog(Path(args.catalog))
    items = catalog.get("items", [])
    if not isinstance(items, list) or not items:
        raise SystemExit("Catalog is empty.")

    selected: dict | None = None
    if args.id:
        selected = next((item for item in items if item.get("id") == args.id), None)
        if selected is None:
            raise SystemExit(f"Template id not found: {args.id}")
    elif args.keyword:
        candidates = find_candidates(items, args.keyword, limit=5)
        if not candidates:
            raise SystemExit(f"No template matched keyword: {args.keyword}")
        selected = candidates[0]
    else:
        raise SystemExit("Provide --id or --keyword")

    template_id = str(selected.get("id"))
    title = str(selected.get("title", template_id))
    file_type = args.type
    download_key = "download_word_url" if file_type == "word" else "download_pdf_url"
    download_url = str(selected.get(download_key, "")).strip()
    if not download_url:
        raise SystemExit(f"Missing {download_key} for template: {template_id}")

    extension = ".docx" if file_type == "word" else ".pdf"
    filename = f"{slugify(title)}_{template_id}{extension}"
    output_path = Path(args.out_dir) / filename

    download_file(download_url, output_path)

    result = {
        "ok": True,
        "id": template_id,
        "title": title,
        "type": file_type,
        "saved_path": str(output_path),
        "view_url": selected.get("view_url"),
        "download_url": download_url,
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

param(
    [string]$Query = "docx"
)

$skillPath = Join-Path $env:USERPROFILE ".agents\skills\docx\SKILL.md"
if (Test-Path $skillPath) {
    Write-Output "INSTALLED"
    Write-Output $skillPath
    exit 0
}

Write-Output "NOT_INSTALLED"
Write-Output "Searching marketplace..."
npx skills find $Query

#!/usr/bin/env python3
"""Basic integrity checks for legal-copilot skill files."""

from __future__ import annotations

import json
from pathlib import Path


REQUIRED_FILES = [
    "SKILL.md",
    "scripts/query_law_api.py",
    "scripts/query_case_api.py",
    "scripts/extract_docx_text.py",
    "scripts/export_to_docx.ps1",
    "scripts/import_contract_library.py",
    "scripts/fetch_samr_template.py",
    "scripts/validate_output.py",
    "scripts/release_skill.ps1",
    "references/workflow-and-intent.md",
    "references/output-standard.md",
    "references/adaptive-response-standard.md",
    "references/case-difference-explainer-standard.md",
    "references/evidence-gap-diagnostic-standard.md",
    "references/evidence-burden-matrix.md",
    "references/samr_contract_templates.json",
    "assets/templates/light_consult_response.md",
    "assets/templates/civil_complaint.md",
    "assets/templates/lawyer_letter.md",
    "assets/templates/judicial_reasoning_simulator.md",
    "assets/templates/case_difference_explainer.md",
    "assets/templates/evidence_gap_diagnostic.md",
    "assets/templates/official/samr/README.md",
]


def main() -> None:
    root = Path(__file__).resolve().parents[1]
    missing: list[str] = []
    for rel in REQUIRED_FILES:
        if not (root / rel).exists():
            missing.append(rel)

    official_dir = root / "assets" / "templates" / "official"
    official_docx_count = len(list(official_dir.glob("*.docx"))) if official_dir.exists() else 0

    result = {
        "ok": not missing,
        "root": str(root),
        "missing_files": missing,
        "official_template_docx_count": official_docx_count,
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))
    if missing:
        raise SystemExit(1)


if __name__ == "__main__":
    main()

"""Import and normalize external contract template catalog into legal-copilot."""

from __future__ import annotations

import argparse
import html
import json
from pathlib import Path


def looks_mojibake(text: str) -> bool:
    markers = ("涓", "鍚", "鎴", "甯", "绗", "妯", "鏍")
    return any(marker in text for marker in markers)


def repair_mojibake(text: str) -> str:
    if not text:
        return text
    try:
        repaired = text.encode("gbk", errors="ignore").decode("utf-8", errors="ignore")
        return repaired if repaired.strip() else text
    except Exception:
        return text


def normalize_title(raw_title: str) -> str:
    title = html.unescape(raw_title or "").strip()
    if looks_mojibake(title):
        fixed = repair_mojibake(title).strip()
        if fixed:
            return fixed
    return title


def build_download_url(template_id: str, file_type: int) -> str:
    return f"https://htsfwb.samr.gov.cn/api/File/DownTemplate?id={template_id}&type={file_type}"


def main() -> None:
    parser = argparse.ArgumentParser(description="Import external contract template library")
    skill_root = Path(__file__).resolve().parents[1]
    parser.add_argument(
        "--input",
        required=True,
        help="Input catalog JSON path (e.g., path/to/all_templates.json)",
    )
    parser.add_argument(
        "--output",
        default=str(skill_root / "references" / "samr_contract_templates.json"),
        help="Output normalized JSON path",
    )
    args = parser.parse_args()

    input_path = Path(args.input)
    output_path = Path(args.output)

    if not input_path.exists():
        raise SystemExit(f"Input not found: {input_path}")

    payload = json.loads(input_path.read_text(encoding="utf-8"))
    templates = payload.get("templates", [])

    normalized_items: list[dict[str, str]] = []
    for item in templates:
        template_id = str(item.get("id", "")).strip()
        if not template_id:
            continue
        title = normalize_title(str(item.get("title", "")))
        source = str(item.get("source", "")).strip() or "SAMR"
        view_url = str(item.get("url", "")).strip() or f"https://htsfwb.samr.gov.cn/View?id={template_id}"
        normalized_items.append(
            {
                "id": template_id,
                "title": title,
                "source": source,
                "view_url": view_url,
                "download_word_url": build_download_url(template_id, 1),
                "download_pdf_url": build_download_url(template_id, 2),
            }
        )

    normalized_items.sort(key=lambda x: x["title"])
    result = {
        "source": "SAMR contract templates",
        "total": len(normalized_items),
        "items": normalized_items,
    }

    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_path.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
    print(str(output_path))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Pack legal-copilot skill into a clean portable zip (POSIX paths)."""

from __future__ import annotations

import argparse
from pathlib import Path
import zipfile


EXCLUDED_DIR_NAMES = {".git", "__pycache__", ".pytest_cache", ".mypy_cache"}
EXCLUDED_FILE_NAMES = {".DS_Store"}
EXCLUDED_SUFFIXES = {".pyc", ".pyo", ".tmp", ".log"}
EXCLUDED_NAME_PREFIXES = {"tmp_"}


def _should_include(path: Path) -> bool:
    rel_parts = set(path.parts)
    if rel_parts & EXCLUDED_DIR_NAMES:
        return False
    if path.name in EXCLUDED_FILE_NAMES:
        return False
    if any(path.name.startswith(prefix) for prefix in EXCLUDED_NAME_PREFIXES):
        return False
    if path.suffix.lower() in EXCLUDED_SUFFIXES:
        return False
    return True


def build_zip(skill_dir: Path, out_zip: Path) -> None:
    if not skill_dir.exists() or not skill_dir.is_dir():
        raise SystemExit(f"skill_dir not found: {skill_dir}")
    if not (skill_dir / "SKILL.md").exists():
        raise SystemExit(f"SKILL.md not found under: {skill_dir}")

    out_zip.parent.mkdir(parents=True, exist_ok=True)
    if out_zip.exists():
        out_zip.unlink()

    with zipfile.ZipFile(out_zip, "w", compression=zipfile.ZIP_DEFLATED) as zf:
        for p in skill_dir.rglob("*"):
            if not p.is_file():
                continue
            rel = p.relative_to(skill_dir)
            if not _should_include(rel):
                continue
            zf.write(p, arcname=rel.as_posix())


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--skill-dir", required=True, help="Path to legal-copilot root")
    parser.add_argument("--out", required=True, help="Output zip path")
    args = parser.parse_args()

    build_zip(Path(args.skill_dir), Path(args.out))
    print(args.out)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Call DeliLegal queryListCase API directly (no MCP dependency)."""

from __future__ import annotations

import argparse
import json
import os
import urllib.error
import urllib.request


API_URL = "https://openapi.delilegal.com/api/qa/v3/search/queryListCase"
APP_ID = os.getenv("LEGAL_APP_ID", "")
SECRET = os.getenv("LEGAL_SECRET", "")

if not APP_ID or not SECRET:
    print(json.dumps({"ok": False, "error": "Missing env vars LEGAL_APP_ID and/or LEGAL_SECRET"}, ensure_ascii=False))
    raise SystemExit(1)


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--payload", help="JSON payload string")
    parser.add_argument("--payload-file", help="Path to JSON payload file")
    parser.add_argument("--query", help="Natural language query for case retrieval")
    parser.add_argument("--page-no", type=int, default=1)
    parser.add_argument("--page-size", type=int, default=5)
    parser.add_argument("--sort-field", default="correlation", choices=["correlation", "time"])
    parser.add_argument("--sort-order", default="desc", choices=["asc", "desc"])
    parser.add_argument("--output", "-o", help="Write result to file instead of stdout (avoids encoding issues)")
    args = parser.parse_args()

    selected_count = sum(bool(x) for x in [args.payload, args.payload_file, args.query])
    if selected_count != 1:
        print(
            json.dumps(
                {"ok": False, "error": "Provide exactly one of --payload, --payload-file, or --query"},
                ensure_ascii=False,
            )
        )
        raise SystemExit(1)

    if args.query:
        payload = {
            "pageNo": args.page_no,
            "pageSize": args.page_size,
            "sortField": args.sort_field,
            "sortOrder": args.sort_order,
            "condition": {
                "longText": args.query,
            },
        }
        payload_text = json.dumps(payload, ensure_ascii=False)
    elif args.payload_file:
        with open(args.payload_file, "r", encoding="utf-8-sig") as f:
            payload_text = f.read()
    else:
        payload_text = args.payload or ""

    data = payload_text.encode("utf-8")
    req = urllib.request.Request(
        API_URL,
        data=data,
        method="POST",
        headers={
            "Content-Type": "application/json",
            "appid": APP_ID,
            "secret": SECRET,
        },
    )
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            raw = resp.read()
            # Auto-detect encoding: try UTF-8 first (standard), fallback to GBK/GB2312 (common for CN legal APIs)
            body = _decode_bytes(raw)
            if args.output:
                with open(args.output, "w", encoding="utf-8") as f:
                    f.write(body)
            else:
                print(body)
    except urllib.error.HTTPError as exc:
        result = json.dumps({"ok": False, "status": exc.code, "error": exc.reason}, ensure_ascii=False)
        if args.output:
            with open(args.output, "w", encoding="utf-8") as f:
                f.write(result)
        else:
            print(result)
        raise SystemExit(1)
    except Exception as exc:
        result = json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False)
        if args.output:
            with open(args.output, "w", encoding="utf-8") as f:
                f.write(result)
        else:
            print(result)
        raise SystemExit(1)


def _decode_bytes(raw: bytes) -> str:
    """Decode API response with automatic encoding detection."""
    # Try UTF-8 first (standard JSON encoding)
    for enc in ["utf-8", "gbk", "gb2312", "gb18030"]:
        try:
            text = raw.decode(enc)
            # Validate: decoded text must be valid JSON with no replacement chars
            parsed = json.loads(text)
            return json.dumps(parsed, ensure_ascii=False, indent=None)
        except (UnicodeDecodeError, ValueError):
            continue
    # Last resort: utf-8 with error replacement
    return raw.decode("utf-8", errors="replace")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Call DeliLegal Law API — 支持两种模式：
  Mode 1: 列表查询 (queryListLaw) — 仅返回法规元数据
  Mode 2: 详情增强 (--fetch-detail) — 先查列表，再逐条调用 lawInfo 获取完整内容
"""

from __future__ import annotations

import argparse
import json
import os
import sys
import time
import urllib.error
import urllib.request

# Fix Windows console encoding for Chinese characters
sys.stdout.reconfigure(encoding='utf-8', errors='replace')
sys.stderr.reconfigure(encoding='utf-8', errors='replace')

# API Endpoints
LIST_URL = "https://openapi.delilegal.com/api/qa/v3/search/queryListLaw"
DETAIL_URL_TEMPLATE = "https://openapi.delilegal.com/api/qa/v3/search/lawInfo?lawId={law_id}&merge=true"

APP_ID = os.getenv("LEGAL_APP_ID", "")
SECRET = os.getenv("LEGAL_SECRET", "")


def get_headers() -> dict:
    """Build auth headers from environment variables."""
    if not APP_ID or not SECRET:
        return {}
    return {
        "Content-Type": "application/json",
        "appid": APP_ID,
        "secret": SECRET,
    }


def check_env() -> bool:
    """Verify environment variables are set."""
    if not APP_ID or not SECRET:
        print(json.dumps(
            {"ok": False, "error": "Missing env vars LEGAL_APP_ID and/or LEGAL_SECRET"},
            ensure_ascii=False,
        ))
        return False
    return True


def query_law_list(payload_text: str, timeout: int = 30) -> dict:
    """
    Step 1: Call queryListLaw API to get law metadata list.
    
    Args:
        payload_text: JSON-encoded request body string
        
    Returns:
        Parsed JSON response dict
    """
    data = payload_text.encode("utf-8")
    req = urllib.request.Request(
        LIST_URL,
        data=data,
        method="POST",
        headers=get_headers(),
    )
    try:
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            body = resp.read().decode("utf-8", errors="ignore")
            return json.loads(body)
    except urllib.error.HTTPError as exc:
        error_body = ""
        try:
            error_body = exc.read().decode("utf-8", errors="ignore") if exc.fp else ""
        except Exception:
            pass
        return {"ok": False, "status": exc.code, "error": exc.reason, "detail": error_body}
    except Exception as exc:
        return {"ok": False, "error": str(exc)}


def fetch_law_detail(law_id: str, timeout: int = 30) -> dict:
    """
    Step 2: Call lawInfo API to get full law content by ID.
    
    Args:
        law_id: The law ID from queryListLaw response
        
    Returns:
        Parsed JSON response containing lawDetailContent field
    """
    url = DETAIL_URL_TEMPLATE.format(law_id=law_id)
    req = urllib.request.Request(url, method="GET", headers=get_headers())
    try:
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            body = resp.read().decode("utf-8", errors="ignore")
            return json.loads(body)
    except urllib.error.HTTPError as exc:
        return {"ok": False, "status": exc.code, "error": exc.reason, "lawId": law_id}
    except Exception as exc:
        return {"ok": False, "error": str(exc), "lawId": law_id}


def enrich_with_details(list_result: dict, delay: float = 0.15, max_details: int = 20) -> dict:
    """
    Enrich law list results with full content from lawInfo API.
    
    Iterates over each law item in the queryListLaw result,
    calls lawInfo for each one, and merges the detail content back.
    
    Args:
        list_result: The parsed JSON from queryListLaw
        delay: Delay between API calls (rate limiting)
        max_details: Maximum number of details to fetch (safety limit)
        
    Returns:
        Enhanced result with 'body.data' items containing 'lawDetailContent'
    """
    if list_result.get("ok") is False:
        return list_result
    
    # Extract data array from nested structure: body -> data
    body = list_result.get("body", {})
    laws = body.get("data", [])
    
    if not laws:
        return list_result
    
    total = len(laws)
    fetch_count = min(total, max_details)
    
    enriched_items = []
    success_count = 0
    fail_count = 0
    
    for i, law in enumerate(laws[:max_details]):
        law_id = law.get("id", "")
        
        if not law_id:
            enriched_items.append({**law, "_detail_error": "No ID found"})
            continue
        
        # Rate limiting between requests
        if i > 0:
            time.sleep(delay)
        
        # Fetch detail
        detail = fetch_law_detail(law_id)
        
        # Check if successful
        if detail.get("success") and detail.get("code") == 0:
            detail_body = detail.get("body", {})
            
            # Merge original metadata + full content
            merged_item = {
                **law,
                "lawDetailContent": detail_body.get("lawDetailContent", ""),
                "items": detail_body.get("items"),
                "_detail_fetched": True,
            }
            success_count += 1
        else:
            merged_item = {
                **law,
                "lawDetailContent": "",
                "_detail_fetched": False,
                "_detail_error": detail.get("error", "Unknown error"),
            }
            fail_count += 1
        
        enriched_items.append(merged_item)
    
    # Build enhanced response
    enhanced_result = {
        **list_result,
        "body": {
            **body,
            "data": enriched_items,
            "_enriched": True,
            "_detail_stats": {
                "total_in_list": total,
                "fetched": fetch_count,
                "success": success_count,
                "failed": fail_count,
                "skipped": max(0, total - max_details),
            },
        },
    }
    
    return enhanced_result


def main() -> None:
    parser = argparse.ArgumentParser(
        description="DeliLegal 法规检索 API (支持列表+详情双模式)",
        epilog="示例:\n"
               "  python query_law_api.py --query \"民法典租赁合同\"\n"
               "  python query_law_api.py --query \"劳动法\" --page-size 3 --fetch-detail\n"
               "  python query_law_api.py --payload-file input.json --fetch-detail",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("--payload", help="JSON payload string")
    parser.add_argument("--payload-file", help="Path to JSON payload file")
    parser.add_argument("--query", help="Natural language query for law retrieval")
    parser.add_argument("--page-no", type=int, default=1, help="Page number (default: 1)")
    parser.add_argument("--page-size", type=int, default=5, help="Results per page (default: 5)")
    parser.add_argument("--sort-field", default="correlation", choices=["correlation", "activeDate"])
    parser.add_argument("--sort-order", default="desc", choices=["asc", "desc"])
    parser.add_argument("--field-name", default="semantic", choices=["title", "semantic"],
                        help="'title' for keyword search, 'semantic' for semantic search (default: semantic)")
    parser.add_argument("--fetch-detail", action="store_true",
                        help="Enable: after getting list, call lawInfo API for each law to get full content")
    parser.add_argument("--detail-delay", type=float, default=0.15,
                        help="Delay in seconds between detail API calls (default: 0.15)")
    parser.add_argument("--max-details", type=int, default=20,
                        help="Maximum number of detail calls (safety limit, default: 20)")
    parser.add_argument("--output", "-o",
                        help="Write result to file instead of stdout (avoids Windows encoding issues)")
    args = parser.parse_args()

    # Validate env
    if not check_env():
        raise SystemExit(1)

    # Validate exactly one input source
    selected_count = sum(bool(x) for x in [args.payload, args.payload_file, args.query])
    if selected_count != 1:
        print(json.dumps(
            {"ok": False, "error": "Provide exactly one of --payload, --payload-file, or --query"},
            ensure_ascii=False,
        ))
        raise SystemExit(1)

    # Build payload
    if args.query:
        payload = {
            "pageNo": args.page_no,
            "pageSize": args.page_size,
            "sortField": args.sort_field,
            "sortOrder": args.sort_order,
            "condition": {
                "keywords": [args.query],
                "fieldName": args.field_name,
            },
        }
        payload_text = json.dumps(payload, ensure_ascii=False)
    elif args.payload_file:
        with open(args.payload_file, "r", encoding="utf-8-sig") as f:
            payload_text = f.read()
    else:
        payload_text = args.payload or ""

    # Step 1: Query law list
    print(f"{'='*60}", file=sys.stderr)
    print(f"[Step 1] 查询法规列表...", file=sys.stderr)
    print(f"{'='*60}", file=sys.stderr)

    list_result = query_law_list(payload_text)
    
    # Check for immediate failure
    if list_result.get("ok") is False:
        print(json.dumps(list_result, ensure_ascii=False))
        raise SystemExit(1)

    # If no detail needed, output list result directly
    if not args.fetch_detail:
        _output_result(list_result, args.output)
        print(file=sys.stderr)
        print(f"[Done] 返回 {len(list_result.get('body', {}).get('data', []))} 条法规元数据", file=sys.stderr)
        return

    # Step 2: Fetch details for each law
    total_laws = len(list_result.get("body", {}).get("data", []))
    fetch_limit = min(total_laws, args.max_details)
    
    print(file=sys.stderr)
    print(f"{'='*60}", file=sys.stderr)
    print(f"[Step 2] 获取法规详情内容 ({fetch_limit}/{total_laws}条)...", file=sys.stderr)
    print(f"{'='*60}", file=sys.stderr)

    enriched_result = enrich_with_details(
        list_result,
        delay=args.detail_delay,
        max_details=args.max_details,
    )

    stats = enriched_result.get("body", {}).get("_detail_stats", {})
    print(file=sys.stderr)
    print(f"{'='*60}", file=sys.stderr)
    print(f"[Done] 详情获取完成:", file=sys.stderr)
    print(f"  成功: {stats.get('success', 0)} | 失败: {stats.get('failed', 0)} | 跳过: {stats.get('skipped', 0)}", file=sys.stderr)
    print(f"{'='*60}", file=sys.stderr)

    # Output final result (compact JSON)
    _output_result(enriched_result, args.output)


def _output_result(result: dict, output_path: str = None) -> None:
    """Output result to stdout or file (file avoids Windows encoding issues)."""
    text = json.dumps(result, ensure_ascii=False, indent=None)
    if output_path:
        with open(output_path, "w", encoding="utf-8") as f:
            f.write(text)
    else:
        print(text)


if __name__ == "__main__":
    main()

param(
  [string]$BackendUrl = "http://localhost:18000",
  [string]$UserId = "default",
  [string]$SkillName = "legal-copilot"
)

$ErrorActionPreference = "Stop"

$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
$skillDir = Split-Path -Parent $scriptDir
$zipPath = Join-Path (Split-Path -Parent $skillDir) "legal-copilot-portable.zip"

Write-Host "[1/4] Running health check..."
python (Join-Path $scriptDir "health_check.py") | Out-Null

Write-Host "[2/4] Packing skill..."
python (Join-Path $scriptDir "pack_skill_zip.py") --skill-dir $skillDir --out $zipPath | Out-Null

Write-Host "[3/4] Discovering import candidates..."
$discoverRaw = curl.exe -sS -X POST "$BackendUrl/api/v1/skills/import/discover" -H "X-User-Id: $UserId" -F "file=@$zipPath"
$discover = $discoverRaw | ConvertFrom-Json
if (-not $discover.data.archive_key) {
  throw "Discover failed: $discoverRaw"
}

$commitBody = @{
  archive_key = $discover.data.archive_key
  selections = @(@{ relative_path = "."; name_override = $SkillName })
} | ConvertTo-Json -Depth 10

$commit = Invoke-RestMethod -Method Post -Uri "$BackendUrl/api/v1/skills/import/commit" -Headers @{
  "X-User-Id" = $UserId
  "Content-Type" = "application/json; charset=utf-8"
} -Body $commitBody

$jobId = $commit.data.job_id
if (-not $jobId) {
  throw "Commit failed: missing job id"
}

Write-Host "[4/4] Waiting import job: $jobId"
$deadline = (Get-Date).AddSeconds(60)
$job = $null
while ((Get-Date) -lt $deadline) {
  Start-Sleep -Milliseconds 700
  $job = Invoke-RestMethod -Method Get -Uri "$BackendUrl/api/v1/skills/import/jobs/$jobId" -Headers @{ "X-User-Id" = $UserId }
  if ($job.data.status -in @("success", "failed")) { break }
}

if (-not $job) { throw "Import job polling failed." }

$item = $job.data.result.items[0]
[pscustomobject]@{
  job_id = $jobId
  status = $job.data.status
  skill_id = $item.skill_id
  skill_name = $item.skill_name
  overwritten = $item.overwritten
} | ConvertTo-Json -Depth 8

requests>=2.28
python-docx>=0.8.11

#!/usr/bin/env python3
"""Lightweight markdown output validator for legal-copilot."""

from __future__ import annotations

import argparse
from pathlib import Path


COMMON_SECTIONS = [
    "# 文书处理结果",
    "## 一、任务类型识别",
    "## 二、处理结果",
    "## 三、检索结果清单（原始条目）",
    "## 六、检索执行信息",
    "# 风险提示",
]

NEXT_STEP_SECTION_CANDIDATES = [
    "## 四、需补充信息（如有）",
    "## 五、下一步建议",
]

EXECUTION_INFO_REQUIRED_KEYS = [
    "queryListLaw",
    "queryListCase",
]


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("file", help="Markdown output file path")
    args = parser.parse_args()

    text = Path(args.file).read_text(encoding="utf-8")

    missing = [s for s in COMMON_SECTIONS if s not in text]
    if missing:
        print("INVALID")
        for item in missing:
            print(f"- missing section: {item}")
        raise SystemExit(1)

    has_next_step = any(s in text for s in NEXT_STEP_SECTION_CANDIDATES)
    if not has_next_step:
        print("INVALID")
        print("- missing section: ## 四、需补充信息（如有） or ## 五、下一步建议")
        raise SystemExit(1)

    missing_exec_keys = [k for k in EXECUTION_INFO_REQUIRED_KEYS if k not in text]
    if missing_exec_keys:
        print("INVALID")
        for key in missing_exec_keys:
            print(f"- missing retrieval execution key: {key}")
        raise SystemExit(1)

    print("VALID")


if __name__ == "__main__":
    main()