version: 1
metadata:
  key: "code-review"
interface:
  display_name: "Code Review"
  short_description: "Risk-driven PR/diff code review with P0/P1/P2 findings and actionable fixes; triggers include code review and PR review."
  default_prompt: "Use the code-review skill to review this change with P0/P1/P2 findings and actionable fixes."
policy:
  allow_implicit_invocation: true

schema_version: v1alpha1

environment:
  type: none

skills:
  - source: local_path
    path: .

engine:
  name: claude_code

cases:
  files:
    - evals/cases/basic-success.yaml
    - evals/cases/edge-incomplete-input.yaml
    - evals/cases/edge-missing-code-version.yaml
    - evals/cases/edge-risk-priority.yaml
  defaults:
    timeout_seconds: 180
    max_turns: 8
    expect:
      exit_code: 0
      must_not_contain:
        - "TODO"
        - "I cannot"

report:
  formats: [json]

# Examples

Desensitized sample input/output for calibration. Replace with your real diff and strip any secrets.

- `sample-diff-review.md`: a payment-callback change with idempotency risk, plus an expected review shape.

# Example: Payment Callback Missing Idempotency

## Input (redacted)

**Business goal**: On successful payment callback, move the order from Pending Payment to Paid.

**Stack**: Java / Spring; order state in MySQL.

**Diff sketch**:

```java
// OrderPaymentController.java
@PostMapping("/callback/pay")
public void onPaySuccess(@RequestBody PayCallback req) {
    orderService.markPaid(req.getOrderId());
    // no idempotency key / no state guard
}
```

## Expected Review Focus (sketch)

### 1. Change Summary and Overall Assessment

- Business goal: payment callback drives order state change
- Overall risk: **High** (callbacks may retry; duplicate side effects possible)

### 2. Findings

#### [P0 - Blocker]

- File and location: `OrderPaymentController.java` (callback entry)
- Category: idempotency / financial-loss risk
- Risk: channel retries may re-enter `markPaid` and downstream side effects (coupons, ledger), causing bad state or duplicate fulfillment
- Fix: idempotency on `orderId + paymentId`; allow only `PENDING -> PAID`; put side effects behind the same dedupe/transaction boundary

#### [P1] / [P2]

- Add as needed for missing signature verification, tracing, failure/retry semantics

### 5. Residual Risks and Gaps

- Assumption: `markPaid` itself is not idempotent (implementation not provided)
- Need: full `orderService.markPaid`, any existing dedupe table, callback signature checks

{
  "meta": {
    "skill": "",
    "scope": "",
    "environment": "",
    "priority": ""
  },
  "inputs": {
    "requirement": "",
    "constraints": [],
    "risks": []
  },
  "execution": [
    { "step": 1, "action": "", "expected": "" }
  ],
  "results": {
    "status": "",
    "evidence": [],
    "defects": []
  },
  "next_actions": [
    { "owner": "", "eta": "", "action": "" }
  ]
}

# Code Review Report Template

## 1. Change Summary and Overall Assessment
- Business goal understanding:
- Change size:
- Overall risk rating: High / Medium / Low
- Rationale:

## 2. Findings

### [P0 - Blocker]
- File and location:
- Category:
- Risk description:
- Fix guidance:

### [P1 - Should fix this iteration]
- (same structure; write "None" if empty)

### [P2 - Optional]
- (same structure; write "None" if empty)

## 3. Testability and Observability
- Testing gaps:
- Logging / metrics / tracing:

## 4. Recommended Fix Order
1.
2.

## 5. Residual Risks and Gaps
- Assumptions:
- Missing info:

QA Report
=========

1. Basic Information
- Skill:
- Scope:
- Environment:
- Priority:

2. Requirement and Constraints
- Requirement:
- Constraints:
- Risks:

3. Test/Review Process
- Step 1:
- Step 2:
- Step 3:

4. Outcome
- Status:
- Evidence:
- Defects:

5. Follow-up Plan
- Owner:
- ETA:
- Action:

# QA Output Mindmap

- QA Output
  - Meta
    - Skill
    - Scope
    - Environment
    - Priority
  - Inputs
    - Requirement
    - Constraints
    - Risks
  - Execution
    - Step 1
    - Step 2
    - Step 3
  - Results
    - Status
    - Evidence
    - Defects
  - Next Actions
    - Owner
    - ETA
    - Action

# Code Review Prompt

Produce a risk-driven, evidence-based, actionable code review report for this PR / diff / commit, catching high-severity defects before merge.

## Role

- Act as a senior code reviewer experienced in distributed systems, concurrency/consistency, financial-loss and security risks, API contracts, and testability.
- Reject rubber-stamp “LGTM”; focus on real risks and executable fixes; critique code, not people.

## Input

- identifiable code version: repository plus a PR, commit, branch, tag, release version, revision, or equivalent stable identity
- reviewable changes for that version: diff/patch, changed-file contents, or an explicit accessible base-to-head repository range
- Business goal, change scope, tech stack, upstream/downstream dependencies (APIs, messaging, DB, cache)
- Team norms, known risks, past incidents, or related test findings (if any)
- optional role reports with declared `source_role`; activate Product and UI/UX reports only when the change touches their concerns

## What to do

1. Check the independent code-identity and reviewable-change gates first; if either is missing, stop the formal review and return a blocked result.
2. Once both gates pass, understand the business goal and change focus; separate new logic from edits to existing paths.
3. Scan for logic defects, concurrency/consistency, financial-loss/security, API compatibility, and testability/maintainability.
4. Rank findings as P0/P1/P2 and provide actionable fix guidance.
5. Return a structured review that supports merge decisions and follow-up.

## Execution Rules

- **Risk-driven**: prioritize production outages, financial loss, security, main-path breakage, and severe maintainability damage; do not list naming/whitespace noise.
- **Two code gates**: identifiable code version and reviewable changes must both exist. With only a diff/code snippet, use `missing_code_identity`; with only repository/PR/commit/branch identity, use `missing_reviewable_change`; when neither exists, list both. Any missing gate prevents formal finding severity and merge conclusions.
- **Blocking is not a speculative first review**: a blocked result records supplied material, the missing gate, why evidence is insufficient, and the exact material required. Do not turn role opinions or verbal descriptions into confirmed code defects, test conclusions, or P0/P1/P2 findings.
- **Optional role input**: role reports are not prerequisites and cannot replace either code gate. Use a Product report only for relevant business rules, state flows, or acceptance semantics. Use a UI/UX report only for relevant UI states, interaction feedback, responsive behavior, or accessibility. Retain `source_role` whenever citing role content and keep it separate from code facts.
- **Evidence-based**: prefer path, line, or snippet with trigger path, repro conditions, and worst-case impact; if you cannot locate precisely, mark the information gap.
- **Strict severity**:
  - **P0**: block merge (financial loss, severe security, reproducible deadlock/OOM, main-path breakage, etc.)
  - **P1**: fix this iteration (edge failures, likely races, clear performance issues, missing core observability, etc.)
  - **P2**: optional / tech debt (non-core smells, readability, minor perf)
- **Actionable fixes**: every finding needs a concrete fix direction or before/after example; ban vague “please optimize this”.
- **Respect constraints**: do not invent APIs/fields/environments; do not demand stack or architecture rewrites without authorization.
- **Stay in scope**: do not force refactors outside this change; you may flag residual risks as tech debt.
- **Secrets**: never put real tokens/passwords/keys in examples; use env vars or placeholders.
- If input contains `{{variable_name}}` placeholders, keep them verbatim.

## Minimum Coverage Checklist

Unless the user explicitly narrows the scope, make sure the result addresses these items:

- change summary and business-goal understanding
- overall risk rating (High / Medium / Low) with rationale
- logic and state defects
- concurrency / consistency / idempotency (when relevant)
- financial-loss and security (including sensitive data leakage)
- API / contract compatibility and upstream/downstream impact (when relevant)
- testability and observability gaps
- high-value maintainability / performance items only
- P0 / P1 / P2 lists (write “None” if empty)
- recommended fix order
- residual risks, assumptions, and information gaps

## Output

If either code gate is missing, stop and return only:

### Code Review Blocked

- `status: blocked`
- `missing_gate`: `missing_code_identity`, `missing_reviewable_change`, or both
- supplied material and why it is insufficient
- exact material required to proceed
- blocking impact, unverified risk scope, and explicitly labeled assumptions (not code findings)
- role-report sources and applicability, if supplied, with a statement that they are not code evidence

Do not append completed severity findings, fix order, or a merge recommendation. Only when both gates pass, return the result in this order:

### 1. Change Summary and Overall Assessment

- Business goal understanding
- Change size (based on provided info; mark unknown)
- Overall risk rating (High / Medium / Low) with one-line rationale

### 2. Findings (severity descending)

#### [P0 - Blocker] (write “None” if empty)

For each finding:

- File and location
- Category
- Risk description (trigger path, repro conditions, worst-case impact)
- Fix guidance (direction or before/after example)

#### [P1 - Should fix this iteration] (write “None” if empty)

Same structure as P0.

#### [P2 - Optional] (write “None” if empty)

Same structure as P0; keep the list short and high-value only.

### 3. Testability and Observability

- Testing gaps or hard-to-test points
- Logging / metrics / tracing suggestions (when relevant)

### 4. Recommended Fix Order

- Order by merge blockers and business impact

### 5. Residual Risks and Gaps

- Unverified items, assumptions, and missing diff/context

## Quality Bar

- Focus on findings and risk, not long praise or generic theory.
- Make every finding concrete; avoid “there is risk” without an example.
- P0/P1 must cite business or technical impact.
- Separate facts from assumptions. If non-gate context is incomplete, a limited review may mark gaps; if either code gate is missing, block.
- When role reports are used, retain their sources and state how they relate to the change; do not require reading, installing, or linking to any role Skill's internal files.

# Extra Review Dimensions (load on demand)

Read this only when you need finer scan dimensions or severity calibration; do not dump the whole file into every review.

## 1. Logic and State

- Null/guard gaps, bounds errors, incomplete state machines
- Swallowed exceptions, silently ignored error codes
- Resource leaks (connections, handles, locks, temp files)

## 2. Concurrency and Distributed Consistency

- Races, lost updates, check-then-act
- Broken idempotency (retries causing double charge/ship/write)
- Misaligned distributed transaction boundaries; cache vs DB drift
- Bad lock granularity, deadlock risk

## 3. Financial Loss and Security

- Money/inventory precision (floats, rounding direction)
- AuthZ gaps, duplicate pay/refund, promo stacking bugs
- Injection (SQL/NoSQL/command/template), XSS
- Sensitive leakage (plaintext tokens/passwords in logs, hardcoded secrets, missing redaction)

## 4. API Contract and Compatibility

- Field add/remove/rename, type/enum changes, default-value semantics
- Breaking forward/backward compatibility, corrupting existing data
- Unexpected impact on callers, consumers, or batch jobs

## 5. Testability and Evolution

- Hard-coded time/randomness, hard-to-mock dependencies
- Missing assertion points or hard-to-build fixtures
- Long methods/classes, misplaced responsibility, magic values, high complexity, tight coupling
- Flag only high-value smells; avoid style nitpicking

## 6. Performance and Resources (high-value only)

- N+1 queries, IO/RPC inside loops, unbounded copies
- Clearly wrong pool/timeout/retry settings
- Leak or unbounded cache growth signals

## 7. Error Handling and Observability

- Whether failures are diagnosable or root cause is swallowed
- Logs with TraceID / key business ids (and redaction)
- Alertable metrics on core paths

## Severity Rubric

| Level | Merge decision | Typical impact |
| --- | --- | --- |
| P0 | Must fix before merge | Financial loss, severe security, main-path failure |
| P1 | Strongly fix this iteration | Likely edge failure, clear perf, core unobservability |
| P2 | Tech debt OK | Non-core maintainability, minor opts |

#!/usr/bin/env python3
import argparse
import subprocess
import sys
from pathlib import Path


def detect_from(file: Path) -> str:
    ext = file.suffix.lower()
    if file.name.endswith('.word.md'):
        return 'markdown'
    return {
        '.md': 'markdown',
        '.markdown': 'markdown',
        '.json': 'json',
        '.csv': 'csv',
        '.tsv': 'excel',
        '.docx': 'word',
        '.xlsx': 'excel',
        '.xmind': 'xmind',
    }.get(ext, 'markdown')


def run_convert(convert_script: Path, src: Path, to_fmt: str, out: Path) -> int:
    cmd = [sys.executable, str(convert_script), str(src), '--from', detect_from(src), '--to', to_fmt, '--output', str(out)]
    return subprocess.call(cmd)


def main() -> None:
    parser = argparse.ArgumentParser(description='Batch convert all template files into target formats.')
    parser.add_argument('--templates-dir', type=Path, default=Path('output-templates'))
    parser.add_argument('--artifacts-dir', type=Path, default=Path('artifacts'))
    parser.add_argument('--targets', default='word,excel,xmind,json,csv,markdown', help='comma-separated target formats')
    parser.add_argument('--skip-same', action='store_true', help='skip conversion when source format equals target format')
    args = parser.parse_args()

    cwd = Path.cwd()
    templates_dir = (cwd / args.templates_dir).resolve()
    artifacts_dir = (cwd / args.artifacts_dir).resolve()
    artifacts_dir.mkdir(parents=True, exist_ok=True)

    local_convert = (Path(__file__).resolve().parent / 'convert_formats.py').resolve()
    targets = [t.strip() for t in args.targets.split(',') if t.strip()]

    if not templates_dir.exists():
        raise SystemExit(f'templates directory not found: {templates_dir}')

    files = [p for p in sorted(templates_dir.iterdir()) if p.is_file()]
    total = 0
    failed = 0

    for src in files:
        src_fmt = detect_from(src)
        for to_fmt in targets:
            if args.skip_same and src_fmt == to_fmt:
                continue
            out_ext = {
                'json': '.json',
                'csv': '.csv',
                'excel': '.tsv',
                'markdown': '.md',
                'word': '.word.md',
                'xmind': '.xmind.md',
            }[to_fmt]
            out = artifacts_dir / f"{src.stem}.to-{to_fmt}{out_ext}"
            total += 1
            rc = run_convert(local_convert, src, to_fmt, out)
            if rc != 0:
                failed += 1
                print(f'[FAILED] {src.name} -> {to_fmt}')
            else:
                print(f'[OK] {src.name} -> {out.name}')

    print(f'\nDone. total={total}, failed={failed}, artifacts={artifacts_dir}')
    if failed:
        raise SystemExit(1)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
import argparse
import csv
import json
import re
import zipfile
from pathlib import Path
from typing import Any
from xml.etree import ElementTree as ET


# ---- parsing ----
def parse_markdown(path: Path) -> dict[str, Any]:
    text = path.read_text(encoding="utf-8", errors="ignore")
    lines = text.splitlines()
    headings: list[dict[str, Any]] = []
    for line in lines:
        m = re.match(r"^(#{1,6})\s+(.*)$", line.strip())
        if m:
            headings.append({"level": len(m.group(1)), "title": m.group(2).strip()})
    return {"title": headings[0]["title"] if headings else path.stem, "headings": headings, "text": text}


def parse_json(path: Path) -> dict[str, Any]:
    data = json.loads(path.read_text(encoding="utf-8", errors="ignore"))
    return {"title": path.stem, "data": data}


def parse_csv_file(path: Path) -> dict[str, Any]:
    with path.open("r", encoding="utf-8", errors="ignore", newline="") as f:
        reader = csv.DictReader(f)
        rows = list(reader)
    return {"title": path.stem, "columns": reader.fieldnames or [], "rows": rows}


def parse_docx(path: Path) -> dict[str, Any]:
    paragraphs: list[str] = []
    with zipfile.ZipFile(path) as zf:
        with zf.open("word/document.xml") as f:
            root = ET.fromstring(f.read())
    ns = {"w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"}
    for p in root.findall(".//w:p", ns):
        texts = [t.text for t in p.findall(".//w:t", ns) if t.text]
        s = "".join(texts).strip()
        if s:
            paragraphs.append(s)
    return {"title": path.stem, "paragraphs": paragraphs}


def _shared_strings(zf: zipfile.ZipFile) -> list[str]:
    out: list[str] = []
    try:
        with zf.open("xl/sharedStrings.xml") as f:
            root = ET.fromstring(f.read())
        ns = {"a": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
        for si in root.findall(".//a:si", ns):
            out.append("".join((t.text or "") for t in si.findall(".//a:t", ns)))
    except KeyError:
        pass
    return out


def parse_xlsx(path: Path) -> dict[str, Any]:
    rows: list[list[str]] = []
    with zipfile.ZipFile(path) as zf:
        shared = _shared_strings(zf)
        with zf.open("xl/worksheets/sheet1.xml") as f:
            root = ET.fromstring(f.read())
    ns = {"a": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
    for row in root.findall(".//a:sheetData/a:row", ns):
        vals = []
        for c in row.findall("a:c", ns):
            t = c.attrib.get("t")
            v = c.find("a:v", ns)
            if v is None or v.text is None:
                vals.append("")
            elif t == "s":
                idx = int(v.text)
                vals.append(shared[idx] if 0 <= idx < len(shared) else "")
            else:
                vals.append(v.text)
        rows.append(vals)
    return {"title": path.stem, "rows": rows}


def parse_xmind(path: Path) -> dict[str, Any]:
    with zipfile.ZipFile(path) as zf:
        names = set(zf.namelist())
        topics: list[str] = []
        if "content.json" in names:
            data = json.loads(zf.read("content.json").decode("utf-8", errors="ignore"))

            def walk(node: Any):
                if isinstance(node, dict):
                    t = node.get("title")
                    if isinstance(t, str) and t.strip():
                        topics.append(t.strip())
                    for k in ("children", "topics", "rootTopic", "attached"):
                        walk(node.get(k))
                elif isinstance(node, list):
                    for i in node:
                        walk(i)

            walk(data)
        elif "content.xml" in names:
            root = ET.fromstring(zf.read("content.xml"))
            topics = [e.text.strip() for e in root.findall(".//title") if e.text and e.text.strip()]
        else:
            raise ValueError("Unsupported XMind package structure")
    return {"title": topics[0] if topics else path.stem, "topics": topics}


def detect_in_format(path: Path, forced: str | None) -> str:
    if forced and forced != "auto":
        return forced
    return {
        ".md": "markdown",
        ".markdown": "markdown",
        ".json": "json",
        ".csv": "csv",
        ".docx": "word",
        ".xlsx": "excel",
        ".xmind": "xmind",
        ".tsv": "excel",
    }.get(path.suffix.lower(), "markdown")


def normalize(parsed: dict[str, Any]) -> dict[str, Any]:
    title = parsed.get("title") or "QA Output"
    sections: list[dict[str, Any]] = []

    if "text" in parsed:
        sections.append({"name": "content", "items": [{"key": "text", "value": parsed["text"]}]})
    if "headings" in parsed:
        sections.append({"name": "headings", "items": [{"key": "heading", "value": h.get("title", "")} for h in parsed["headings"]]})
    if "data" in parsed:
        data = parsed["data"]
        if isinstance(data, dict):
            items = [{"key": k, "value": v} for k, v in list(data.items())[:100]]
            sections.append({"name": "json_object", "items": items})
        elif isinstance(data, list):
            sections.append({"name": "json_array", "items": [{"key": "row", "value": v} for v in data[:200]]})
        else:
            sections.append({"name": "json_value", "items": [{"key": "value", "value": data}]})
    if "rows" in parsed:
        rows = parsed["rows"]
        sections.append({"name": "rows", "items": [{"key": f"row_{i+1}", "value": r} for i, r in enumerate(rows[:200])]})
    if "columns" in parsed:
        sections.append({"name": "columns", "items": [{"key": "column", "value": c} for c in parsed["columns"]]})
    if "paragraphs" in parsed:
        sections.append({"name": "paragraphs", "items": [{"key": f"p{i+1}", "value": p} for i, p in enumerate(parsed["paragraphs"][:200])]})
    if "topics" in parsed:
        sections.append({"name": "topics", "items": [{"key": "topic", "value": t} for t in parsed["topics"][:300]]})

    return {"title": title, "sections": sections}


# ---- writers ----
def write_json(model: dict[str, Any], output: Path) -> None:
    output.write_text(json.dumps(model, ensure_ascii=False, indent=2), encoding="utf-8")


def _scalar(v: Any) -> str:
    if isinstance(v, (dict, list)):
        return json.dumps(v, ensure_ascii=False)
    return str(v)


def write_csv(model: dict[str, Any], output: Path) -> None:
    with output.open("w", encoding="utf-8", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["section", "key", "value"])
        for s in model.get("sections", []):
            for item in s.get("items", []):
                writer.writerow([s.get("name", ""), item.get("key", ""), _scalar(item.get("value", ""))])


def write_excel_tsv(model: dict[str, Any], output: Path) -> None:
    lines = ["Section\tKey\tValue"]
    for s in model.get("sections", []):
        for item in s.get("items", []):
            lines.append(f"{s.get('name','')}\t{item.get('key','')}\t{_scalar(item.get('value','')).replace(chr(9), ' ')}")
    output.write_text("\n".join(lines) + "\n", encoding="utf-8")


def write_markdown(model: dict[str, Any], output: Path) -> None:
    lines = [f"# {model.get('title', 'QA Output')}", ""]
    for s in model.get("sections", []):
        lines.append(f"## {s.get('name', 'section')}")
        for item in s.get("items", []):
            lines.append(f"- **{item.get('key','key')}**: {_scalar(item.get('value',''))}")
        lines.append("")
    output.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")


def write_word_md(model: dict[str, Any], output: Path) -> None:
    lines = [model.get("title", "QA Output"), "=" * len(model.get("title", "QA Output")), ""]
    idx = 1
    for s in model.get("sections", []):
        lines.append(f"{idx}. {s.get('name', 'section').replace('_', ' ').title()}")
        for item in s.get("items", []):
            lines.append(f"- {item.get('key','key')}: {_scalar(item.get('value',''))}")
        lines.append("")
        idx += 1
    output.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")


def write_xmind_md(model: dict[str, Any], output: Path) -> None:
    lines = [f"# {model.get('title', 'QA Output')}", "", f"- {model.get('title', 'QA Output')}"]
    for s in model.get("sections", []):
        lines.append(f"  - {s.get('name', 'section')}")
        for item in s.get("items", []):
            lines.append(f"    - {item.get('key','key')}: {_scalar(item.get('value',''))}")
    output.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")


def default_output(input_path: Path, to_fmt: str) -> Path:
    ext = {
        "json": ".json",
        "csv": ".csv",
        "excel": ".tsv",
        "markdown": ".md",
        "word": ".word.md",
        "xmind": ".xmind.md",
    }[to_fmt]
    return input_path.with_name(input_path.stem + ".converted" + ext)


def main() -> None:
    parser = argparse.ArgumentParser(description="Convert QA output files between common formats")
    parser.add_argument("input", type=Path, help="Input file path")
    parser.add_argument("--from", dest="from_fmt", default="auto", choices=["auto", "word", "excel", "xmind", "json", "csv", "markdown"])
    parser.add_argument("--to", required=True, choices=["word", "excel", "xmind", "json", "csv", "markdown"])
    parser.add_argument("--output", type=Path, help="Output file path")
    args = parser.parse_args()

    in_fmt = detect_in_format(args.input, args.from_fmt)
    if in_fmt == "word":
        parsed = parse_docx(args.input)
    elif in_fmt == "excel":
        if args.input.suffix.lower() == ".tsv":
            rows = [line.rstrip("\n").split("\t") for line in args.input.read_text(encoding="utf-8", errors="ignore").splitlines() if line]
            parsed = {"title": args.input.stem, "rows": rows}
        else:
            parsed = parse_xlsx(args.input)
    elif in_fmt == "xmind":
        parsed = parse_xmind(args.input)
    elif in_fmt == "json":
        parsed = parse_json(args.input)
    elif in_fmt == "csv":
        parsed = parse_csv_file(args.input)
    else:
        parsed = parse_markdown(args.input)

    model = normalize(parsed)
    output = args.output or default_output(args.input, args.to)

    if args.to == "json":
        write_json(model, output)
    elif args.to == "csv":
        write_csv(model, output)
    elif args.to == "excel":
        write_excel_tsv(model, output)
    elif args.to == "markdown":
        write_markdown(model, output)
    elif args.to == "word":
        write_word_md(model, output)
    else:
        write_xmind_md(model, output)

    print(str(output))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'convert_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'convert_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--to', 'csv'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'convert_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--to', 'excel'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'convert_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--to', 'json'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'convert_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--to', 'markdown'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'convert_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--to', 'word'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'convert_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--to', 'xmind'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'parse_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--format', 'csv'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'parse_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--format', 'excel'] + sys.argv[1:]))

#!/usr/bin/env python3
import argparse
import csv
import json
import re
import zipfile
from pathlib import Path
from typing import Any
from xml.etree import ElementTree as ET


def parse_markdown(path: Path) -> dict[str, Any]:
    text = path.read_text(encoding="utf-8", errors="ignore")
    headings = []
    for line in text.splitlines():
        m = re.match(r"^(#{1,6})\s+(.*)$", line.strip())
        if m:
            headings.append({"level": len(m.group(1)), "title": m.group(2).strip()})
    return {"format": "markdown", "headings": headings, "preview": text[:500]}


def parse_json(path: Path) -> dict[str, Any]:
    data = json.loads(path.read_text(encoding="utf-8", errors="ignore"))
    if isinstance(data, dict):
        shape = {"type": "object", "keys": list(data.keys())[:50]}
    elif isinstance(data, list):
        shape = {"type": "array", "size": len(data)}
    else:
        shape = {"type": type(data).__name__}
    return {"format": "json", "shape": shape, "data": data}


def parse_csv_file(path: Path) -> dict[str, Any]:
    with path.open("r", encoding="utf-8", errors="ignore", newline="") as f:
        reader = csv.DictReader(f)
        rows = list(reader)
    return {
        "format": "csv",
        "columns": reader.fieldnames or [],
        "row_count": len(rows),
        "sample_rows": rows[:10],
    }


def parse_docx(path: Path) -> dict[str, Any]:
    paragraphs = []
    with zipfile.ZipFile(path) as zf:
        with zf.open("word/document.xml") as f:
            root = ET.fromstring(f.read())
    ns = {"w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"}
    for p in root.findall(".//w:p", ns):
        texts = [t.text for t in p.findall(".//w:t", ns) if t.text]
        joined = "".join(texts).strip()
        if joined:
            paragraphs.append(joined)
    return {"format": "word", "paragraph_count": len(paragraphs), "paragraphs": paragraphs[:100]}


def _read_shared_strings(zf: zipfile.ZipFile) -> list[str]:
    strings = []
    try:
        with zf.open("xl/sharedStrings.xml") as f:
            root = ET.fromstring(f.read())
        ns = {"a": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
        for si in root.findall(".//a:si", ns):
            parts = [t.text or "" for t in si.findall(".//a:t", ns)]
            strings.append("".join(parts))
    except KeyError:
        pass
    return strings


def parse_xlsx(path: Path) -> dict[str, Any]:
    rows_out: list[list[str]] = []
    with zipfile.ZipFile(path) as zf:
        shared = _read_shared_strings(zf)
        with zf.open("xl/worksheets/sheet1.xml") as f:
            root = ET.fromstring(f.read())
    ns = {"a": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
    for row in root.findall(".//a:sheetData/a:row", ns):
        vals = []
        for c in row.findall("a:c", ns):
            cell_type = c.attrib.get("t")
            v = c.find("a:v", ns)
            if v is None or v.text is None:
                vals.append("")
                continue
            if cell_type == "s":
                idx = int(v.text)
                vals.append(shared[idx] if 0 <= idx < len(shared) else "")
            else:
                vals.append(v.text)
        rows_out.append(vals)
    return {"format": "excel", "row_count": len(rows_out), "sample_rows": rows_out[:20]}


def parse_xmind(path: Path) -> dict[str, Any]:
    with zipfile.ZipFile(path) as zf:
        names = set(zf.namelist())
        if "content.json" in names:
            data = json.loads(zf.read("content.json").decode("utf-8", errors="ignore"))
            titles: list[str] = []

            def walk(node: Any):
                if isinstance(node, dict):
                    title = node.get("title")
                    if isinstance(title, str) and title.strip():
                        titles.append(title.strip())
                    for k in ("children", "topics", "rootTopic", "attached"):
                        walk(node.get(k))
                elif isinstance(node, list):
                    for i in node:
                        walk(i)

            walk(data)
            return {"format": "xmind", "topic_count": len(titles), "topics": titles[:200]}
        if "content.xml" in names:
            root = ET.fromstring(zf.read("content.xml"))
            titles = [el.text.strip() for el in root.findall(".//title") if el.text and el.text.strip()]
            return {"format": "xmind", "topic_count": len(titles), "topics": titles[:200]}
    raise ValueError("Unsupported XMind package structure")


def detect_format(path: Path, forced: str | None) -> str:
    if forced and forced != "auto":
        return forced
    ext = path.suffix.lower()
    return {
        ".md": "markdown",
        ".markdown": "markdown",
        ".json": "json",
        ".csv": "csv",
        ".docx": "word",
        ".xlsx": "excel",
        ".xmind": "xmind",
    }.get(ext, "markdown")


def main() -> None:
    parser = argparse.ArgumentParser(description="Parse common QA output formats into normalized JSON")
    parser.add_argument("input", type=Path, help="Input file path")
    parser.add_argument("--format", default="auto", choices=["auto", "word", "excel", "xmind", "json", "csv", "markdown"])
    parser.add_argument("--output", type=Path, help="Output JSON path (default: stdout)")
    args = parser.parse_args()

    fmt = detect_format(args.input, args.format)
    if fmt == "word":
        result = parse_docx(args.input)
    elif fmt == "excel":
        result = parse_xlsx(args.input)
    elif fmt == "xmind":
        result = parse_xmind(args.input)
    elif fmt == "json":
        result = parse_json(args.input)
    elif fmt == "csv":
        result = parse_csv_file(args.input)
    else:
        result = parse_markdown(args.input)

    result["source"] = str(args.input)
    out = json.dumps(result, ensure_ascii=False, indent=2)
    if args.output:
        args.output.write_text(out, encoding="utf-8")
    else:
        print(out)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'parse_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--format', 'json'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'parse_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--format', 'markdown'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'parse_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'parse_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--format', 'word'] + sys.argv[1:]))

#!/usr/bin/env python3
import os
import subprocess
import sys
LOCAL = os.path.normpath(os.path.join(os.path.dirname(__file__), 'parse_formats.py'))
if __name__ == '__main__':
    raise SystemExit(subprocess.call([sys.executable, LOCAL, '--format', 'xmind'] + sys.argv[1:]))