deepextract-skill 0.1.0

package/README.md

@@ -0,0 +1,22 @@
+# deepextract-skill
+
+Install the `deepextract-doc-converter` skill into OpenCode via `npx`.
+
+## Usage
+
+```bash
+npx deepextract-skill
+```
+
+This installs the skill to:
+
+`~/.config/opencode/skills/deepextract-doc-converter`
+
+## After install
+
+Set environment variables (recommended):
+
+```bash
+export DEEPEXTRACT_ROOT="/absolute/path/to/deepextract"
+export MINERU_API_KEY="your_mineru_key"
+```

package/bin/install.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function log(msg) {
+  process.stdout.write(`${msg}\n`);
+}
+
+function copyDir(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function ensureExecutable(filePath) {
+  if (process.platform === "win32") return;
+  const st = fs.statSync(filePath);
+  fs.chmodSync(filePath, st.mode | 0o111);
+}
+
+function main() {
+  const home = os.homedir();
+  const skillBase = path.join(home, ".config", "opencode", "skills");
+  const skillName = "deepextract-doc-converter";
+  const target = path.join(skillBase, skillName);
+
+  const templateRoot = path.join(__dirname, "..", "templates", skillName);
+  if (!fs.existsSync(templateRoot)) {
+    throw new Error(`Template not found: ${templateRoot}`);
+  }
+
+  fs.mkdirSync(skillBase, { recursive: true });
+
+  if (fs.existsSync(target)) {
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+
+  copyDir(templateRoot, target);
+
+  const scriptPath = path.join(target, "scripts", "convert_with_deepextract.py");
+  if (fs.existsSync(scriptPath)) {
+    ensureExecutable(scriptPath);
+  }
+
+  log("[OK] DeepExtract skill installed.");
+  log(`Path: ${target}`);
+  log("");
+  log("Next steps:");
+  log("1) Set DEEPEXTRACT_ROOT to your project path");
+  log("2) Set MINERU_API_KEY globally if needed");
+  log("");
+  log("Example:");
+  log('export DEEPEXTRACT_ROOT="/path/to/deepextract"');
+  log('export MINERU_API_KEY="your_key"');
+}
+
+try {
+  main();
+} catch (err) {
+  process.stderr.write(`[ERROR] ${err.message}\n`);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "deepextract-skill",
+  "version": "0.1.0",
+  "description": "Install DeepExtract document conversion skill into OpenCode",
+  "bin": {
+    "deepextract-skill": "bin/install.js"
+  },
+  "type": "commonjs",
+  "files": [
+    "bin",
+    "templates",
+    "README.md"
+  ],
+  "license": "MIT"
+}

package/templates/deepextract-doc-converter/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: deepextract-doc-converter
+description: Convert documents with local DeepExtract when users ask things like "帮我把这个文档转为xx格式", "转成 Word", "转成 Markdown", or "convert this file to docx/markdown". Use for PDF, images, Word, PPT, HTML, and Markdown inputs, with outputs in Markdown or DOCX.
+---
+
+# DeepExtract Document Converter
+
+Use this skill to execute real local file conversion through the DeepExtract codebase.
+
+## Workflow
+
+1. Parse user intent:
+   - Input file path
+   - Target format (`markdown` or `docx`)
+2. Run the bundled script:
+
+```bash
+python "$HOME/.config/opencode/skills/deepextract-doc-converter/scripts/convert_with_deepextract.py" --input "<input_path>" --target "<target>"
+```
+
+3. If user gave an explicit output file path, add `--output`.
+4. Return the generated result path to the user.
+
+## Target format mapping
+
+- `markdown`, `md` -> Markdown output
+- `word`, `docx`, `doc` -> DOCX output
+
+## Notes
+
+- The script auto-detects project root from current directory or parent directories.
+- For global usage in any directory, set `DEEPEXTRACT_ROOT` to your DeepExtract project path.
+- For MinerU-based conversions, API key is required:
+  - `MINERU_API_KEY` environment variable, or
+  - `apikey.md` with `MINERU_API_KEY=...`
+- If both input path and target are clear, run directly without asking extra questions.

package/templates/deepextract-doc-converter/scripts/convert_with_deepextract.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import shutil
+import sys
+from pathlib import Path
+
+
+def find_project_root(start: Path) -> Path:
+    env_root = os.getenv("DEEPEXTRACT_ROOT", "").strip()
+    if env_root:
+        p = Path(env_root).expanduser().resolve()
+        if (p / "md2word_final.py").exists() and (p / "mineru_extract.py").exists():
+            return p
+        raise FileNotFoundError(
+            f"DEEPEXTRACT_ROOT is set but invalid: {p}. Missing md2word_final.py or mineru_extract.py"
+        )
+
+    cur = start.resolve()
+    candidates = [cur] + list(cur.parents)
+    for p in candidates:
+        if (p / "md2word_final.py").exists() and (p / "mineru_extract.py").exists():
+            return p
+    raise FileNotFoundError("Cannot locate DeepExtract project root.")
+
+
+def normalize_target(target: str) -> str:
+    t = target.strip().lower()
+    if t in {"md", "markdown"}:
+        return "md"
+    if t in {"doc", "docx", "word"}:
+        return "docx"
+    raise ValueError(f"Unsupported target format: {target}")
+
+
+def ensure_key_notice(project_root: Path) -> None:
+    has_env = bool(os.getenv("MINERU_API_KEY", "").strip())
+    key_file = project_root / "apikey.md"
+    has_file_key = False
+    if key_file.exists():
+        for line in key_file.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line.startswith("MINERU_API_KEY=") and line.split("=", 1)[1].strip():
+                has_file_key = True
+                break
+    if not has_env and not has_file_key:
+        print(
+            "[WARN] MINERU_API_KEY not found. Conversions requiring MinerU may fail.",
+            file=sys.stderr,
+        )
+
+
+def convert_markdown_to_docx(project_root: Path, input_file: Path, output_file: Path) -> Path:
+    sys.path.insert(0, str(project_root))
+    import md2word_final
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    md2word_final.convert_with_python_docx(str(input_file), str(output_file))
+    return output_file
+
+
+def convert_with_mineru(project_root: Path, input_file: Path, target: str, output_file: Path) -> Path:
+    sys.path.insert(0, str(project_root))
+    import mineru_extract
+    import md2word_final
+
+    result = mineru_extract.upload_and_extract(str(input_file))
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    if target == "md":
+        src_zip = Path(result["zip_path"])
+        if output_file.suffix.lower() != ".zip":
+            output_file = output_file.with_suffix(".zip")
+        shutil.copy2(src_zip, output_file)
+        return output_file
+
+    md2word_final.convert_with_python_docx(result["md_path"], str(output_file))
+    return output_file
+
+
+def build_default_output(input_file: Path, target: str) -> Path:
+    if target == "md":
+        return input_file.with_suffix(".zip")
+    return input_file.with_suffix(".docx")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Convert files with local DeepExtract")
+    parser.add_argument("--input", required=True, help="Input file path")
+    parser.add_argument("--target", required=True, help="Target format: markdown/docx")
+    parser.add_argument("--output", default="", help="Optional output path")
+    args = parser.parse_args()
+
+    input_file = Path(args.input).expanduser().resolve()
+    if not input_file.exists() or not input_file.is_file():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+
+    target = normalize_target(args.target)
+    output_file = (
+        Path(args.output).expanduser().resolve()
+        if args.output.strip()
+        else build_default_output(input_file, target)
+    )
+
+    project_root = find_project_root(Path.cwd())
+
+    ext = input_file.suffix.lower()
+    markdown_input = {".md", ".markdown"}
+
+    if ext in markdown_input and target == "docx":
+        final_path = convert_markdown_to_docx(project_root, input_file, output_file)
+    elif ext in markdown_input and target == "md":
+        if output_file.suffix.lower() not in {".md", ".markdown"}:
+            output_file = output_file.with_suffix(".md")
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(input_file, output_file)
+        final_path = output_file
+    else:
+        ensure_key_notice(project_root)
+        final_path = convert_with_mineru(project_root, input_file, target, output_file)
+
+    print(str(final_path))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except Exception as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        raise