version: 1
metadata:
  key: "bug-reporting"
interface:
  display_name: "Bug Reporting"
  short_description: "Use this skill when you need to write clear, reproducible bug reports with steps, environment details, and evidence; triggers include bug reporting and defect…"
  default_prompt: "Use the bug-reporting skill to complete this testing task with structured outputs and practical next steps."
policy:
  allow_implicit_invocation: true

schema_version: v1alpha1

environment:
  type: none

skills:
  - source: local_path
    path: .

engine:
  name: claude_code
  # model is optional; omit to use engine default
  # model:
  #   provider: anthropic
  #   name: claude-sonnet-4-6

cases:
  files:
    - evals/cases/basic-success.yaml
    - evals/cases/edge-incomplete-input.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]

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

# QA Output Template

## Summary
- Skill:
- Scope:
- Environment:
- Priority:

## Inputs
- Requirement:
- Constraints:
- Risks:

## Execution
1. Step 1
2. Step 2
3. Step 3

## Results
- Status:
- Evidence:
- Defects:

## Next Actions
- Owner:
- ETA:

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

# Bug Reporting Prompt

Produce a clear, actionable bug report that helps others understand, reproduce, and prioritize the issue quickly.

## Role

- Act as a senior QA expert who writes bug reports that are precise, reproducible, and easy to act on.


## Input

- bug description, screenshots, videos, logs, or repro notes
- environment details, app version, device or browser, and account context
- observed behavior, expected behavior, impact, and frequency

## What to do

1. Clarify what actually happened, where it happened, and how reliably it reproduces.
2. Focus on evidence, impact, and next action instead of storytelling.
3. Produce a report that developers, PMs, and testers can use immediately.

## Execution Rules

- Separate observed facts from guesses about root cause.
- If reproduction is incomplete, state the uncertainty clearly.
- Assess severity and priority using business and user impact, not emotion.

## Minimum Coverage Checklist

Unless the user explicitly narrows the scope, make sure the result addresses these items:
- title
- environment
- preconditions
- repro steps
- actual result
- expected result
- repro frequency
- impact scope
- severity and priority
- evidence
- open questions or missing information

## Output

Return the result in this order:

### 1. Bug Summary
### 2. Environment and Preconditions
### 3. Reproduction Steps
### 4. Actual vs Expected
### 5. Impact Assessment
### 6. Evidence and Notes

## Quality Bar

- Keep steps reproducible and concise.
- Do not invent root cause.
- Do not leave severity unsupported.

#!/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:]))