mdengine 0.6.0__tar.gz → 0.7.0__tar.gz

{mdengine-0.6.0 → mdengine-0.7.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: mdengine
-Version: 0.6.0
+Version: 0.7.0
 Summary: Convert PDF, Office, images, audio, video, text/JSON/XML, ZIP archives, web URLs, databases, graphs, and OpenAPI specs to Markdown.
 Author: mdengine contributors
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/vishal7090/md-generator
 Project-URL: Repository, https://github.com/vishal7090/md-generator
 Project-URL: Issues, https://github.com/vishal7090/md-generator/issues
-Keywords: markdown,pdf,docx,pptx,xlsx,ocr,zip,url,html,youtube,playwright,database,openapi
+Keywords: markdown,pdf,docx,pptx,xlsx,ocr,zip,url,html,youtube,playwright,database,openapi,codeflow
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Text Processing :: Markup :: Markdown
@@ -103,6 +103,16 @@ Provides-Extra: openapi
 Requires-Dist: pyyaml>=6.0.0; extra == "openapi"
 Requires-Dist: prance>=23.6.0; extra == "openapi"
 Requires-Dist: openapi-spec-validator>=0.7.0; extra == "openapi"
+Provides-Extra: codeflow
+Requires-Dist: networkx>=3.2.0; extra == "codeflow"
+Requires-Dist: javalang>=0.13.0; extra == "codeflow"
+Provides-Extra: codeflow-treesitter
+Requires-Dist: tree-sitter>=0.21.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-javascript>=0.21.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-typescript>=0.23.0; extra == "codeflow-treesitter"
+Requires-Dist: tree-sitter-cpp>=0.23.0; extra == "codeflow-treesitter"
+Provides-Extra: codeflow-clang
+Requires-Dist: clang>=16.0.0; extra == "codeflow-clang"
 Provides-Extra: api
 Requires-Dist: fastapi>=0.115.0; extra == "api"
 Requires-Dist: uvicorn[standard]>=0.32.0; extra == "api"
@@ -125,6 +135,8 @@ Requires-Dist: mdengine[playwright]; extra == "dev"
 Requires-Dist: mdengine[db]; extra == "dev"
 Requires-Dist: mdengine[graph]; extra == "dev"
 Requires-Dist: mdengine[openapi]; extra == "dev"
+Requires-Dist: mdengine[codeflow]; extra == "dev"
+Requires-Dist: mdengine[codeflow-treesitter]; extra == "dev"
 Provides-Extra: all
 Requires-Dist: pymupdf>=1.24.0; extra == "all"
 Requires-Dist: pdfplumber>=0.11.0; extra == "all"

{mdengine-0.6.0 → mdengine-0.7.0}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mdengine"
-version = "0.6.0"
+version = "0.7.0"
 description = "Convert PDF, Office, images, audio, video, text/JSON/XML, ZIP archives, web URLs, databases, graphs, and OpenAPI specs to Markdown."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [{ name = "mdengine contributors" }]
-keywords = ["markdown", "pdf", "docx", "pptx", "xlsx", "ocr", "zip", "url", "html", "youtube", "playwright", "database", "openapi"]
+keywords = ["markdown", "pdf", "docx", "pptx", "xlsx", "ocr", "zip", "url", "html", "youtube", "playwright", "database", "openapi", "codeflow"]
 classifiers = [
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
@@ -111,6 +111,19 @@ openapi = [
   "prance>=23.6.0",
   "openapi-spec-validator>=0.7.0",
 ]
+codeflow = [
+  "networkx>=3.2.0",
+  "javalang>=0.13.0",
+]
+codeflow-treesitter = [
+  "tree-sitter>=0.21.0",
+  "tree-sitter-javascript>=0.21.0",
+  "tree-sitter-typescript>=0.23.0",
+  "tree-sitter-cpp>=0.23.0",
+]
+codeflow-clang = [
+  "clang>=16.0.0",
+]
 api = [
   "fastapi>=0.115.0",
   "uvicorn[standard]>=0.32.0",
@@ -132,6 +145,8 @@ dev = [
   "mdengine[db]",
   "mdengine[graph]",
   "mdengine[openapi]",
+  "mdengine[codeflow]",
+  "mdengine[codeflow-treesitter]",
 ]
 all = [
   "pymupdf>=1.24.0",
@@ -196,6 +211,10 @@ md-graph-mcp = "md_generator.graph.api.mcp_server:main"
 md-openapi = "md_generator.openapi.cli.main:main"
 md-openapi-api = "md_generator.openapi.api.run:main"
 md-openapi-mcp = "md_generator.openapi.api.mcp_server:main"
+md-codeflow = "md_generator.codeflow.cli.main:main"
+codeflow = "md_generator.codeflow.cli.main:main"
+md-codeflow-api = "md_generator.codeflow.api.run:main"
+md-codeflow-mcp = "md_generator.codeflow.api.mcp_server:main"
 mdengine = "md_generator.engine_cli:main"
 
 [tool.setuptools.packages.find]
@@ -224,5 +243,6 @@ testpaths = [
   "db-to-md/tests",
   "graph-to-md/tests",
   "openapi-to-md/tests",
+  "codeflow-to-md/tests",
 ]
 markers = ["integration: optional dependency or slower checks"]

{mdengine-0.6.0 → mdengine-0.7.0}/src/md_generator/__init__.py

@@ -1,5 +1,5 @@
 """md_generator: PDF, Office, image, text, and ZIP to Markdown conversion."""
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 
 __all__ = ["__version__"]

mdengine-0.7.0/src/md_generator/codeflow/__init__.py

@@ -0,0 +1,7 @@
+"""Multi-language execution flow extraction → Markdown, Mermaid, graph JSON, HTML."""
+
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

mdengine-0.7.0/src/md_generator/codeflow/analyzers/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from md_generator.codeflow.analyzers.flow_analyzer import (
+    FlowSlice,
+    slice_from_entry,
+    walk_with_depth,
+)
+
+__all__ = ["FlowSlice", "slice_from_entry", "walk_with_depth"]

mdengine-0.7.0/src/md_generator/codeflow/analyzers/flow_analyzer.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import networkx as nx
+
+
+@dataclass(slots=True)
+class FlowSlice:
+    entry_id: str
+    nodes: set[str]
+    edges: list[tuple[str, str, dict]]
+    depth: int
+    cycle_nodes: set[str] = field(default_factory=set)
+    truncated: bool = False
+
+
+def walk_with_depth(
+    g: nx.DiGraph,
+    start: str,
+    max_depth: int,
+) -> tuple[set[str], list[tuple[str, str, dict]], set[str], bool]:
+    """Reachability from start within ``max_depth`` hops (shortest-path layering)."""
+    if start not in g:
+        return {start}, [], set(), False
+    try:
+        plen = nx.single_source_shortest_path_length(g, start, cutoff=max_depth)
+    except nx.NetworkXError:
+        plen = {start: 0}
+
+    nodes = set(plen.keys())
+    edges_out: list[tuple[str, str, dict]] = []
+    cycle_guess: set[str] = set()
+    truncated = False
+
+    for u in nodes:
+        du = plen[u]
+        if du >= max_depth:
+            succ = list(g.successors(u))
+            if succ:
+                truncated = True
+            continue
+        for v in g.successors(u):
+            ed = dict(g.edges[u, v])
+            edges_out.append((u, v, ed))
+            dv = plen.get(v)
+            if dv is not None and dv <= du:
+                cycle_guess.add(v)
+            if v not in plen and du + 1 > max_depth:
+                truncated = True
+
+    return nodes, edges_out, cycle_guess, truncated
+
+
+def slice_from_entry(
+    g: nx.DiGraph,
+    entry_id: str,
+    max_depth: int,
+) -> FlowSlice:
+    nodes, edges, cycles, truncated = walk_with_depth(g, entry_id, max_depth)
+    return FlowSlice(
+        entry_id=entry_id,
+        nodes=nodes,
+        edges=edges,
+        depth=max_depth,
+        cycle_nodes=cycles,
+        truncated=truncated,
+    )

mdengine-0.7.0/src/md_generator/codeflow/api/job_manager.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import json
+import shutil
+import sqlite3
+import threading
+import time
+import uuid
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from md_generator.codeflow.api.schemas import scan_config_dump, scan_config_load
+from md_generator.codeflow.core.extractor import run_scan
+from md_generator.codeflow.core.run_config import ScanConfig
+from md_generator.codeflow.ingestion.loader import LoadedWorkspace
+
+
+@dataclass
+class CodeflowJobRecord:
+    job_id: str
+    status: str
+    progress: int
+    current: str
+    workspace: str
+    zip_path: str | None
+    error: str | None
+    created_at: float
+    updated_at: float
+
+    def to_api_dict(self) -> dict[str, Any]:
+        return {
+            "job_id": self.job_id,
+            "status": self.status,
+            "progress": self.progress,
+            "current": self.current,
+            "workspace": self.workspace,
+            "zip_path": self.zip_path,
+            "error": self.error,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+        }
+
+
+class CodeflowJobManager:
+    """SQLite-backed job store (same pattern as db-to-md ``JobManager``)."""
+
+    def __init__(
+        self,
+        *,
+        sqlite_path: str | Path | None = None,
+        workspace_root: Path | None = None,
+        in_memory: bool = False,
+    ) -> None:
+        self._lock = threading.Lock()
+        self._root = Path(workspace_root) if workspace_root else None
+        if in_memory:
+            self._conn = sqlite3.connect(":memory:", check_same_thread=False)
+        else:
+            path = Path(sqlite_path or _default_sqlite_path())
+            path.parent.mkdir(parents=True, exist_ok=True)
+            self._conn = sqlite3.connect(str(path), check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._init_db()
+
+    def _init_db(self) -> None:
+        assert self._conn is not None
+        self._conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS jobs (
+                job_id TEXT PRIMARY KEY,
+                status TEXT NOT NULL,
+                progress INTEGER NOT NULL DEFAULT 0,
+                current TEXT NOT NULL DEFAULT '',
+                workspace TEXT NOT NULL,
+                zip_path TEXT,
+                error TEXT,
+                created_at REAL NOT NULL,
+                updated_at REAL NOT NULL,
+                config_json TEXT NOT NULL
+            )
+            """
+        )
+        self._conn.commit()
+
+    def close(self) -> None:
+        if self._conn:
+            self._conn.close()
+
+    def create_zip_job(self, zip_bytes: bytes, cfg_template: ScanConfig) -> CodeflowJobRecord:
+        jid = str(uuid.uuid4())
+        base = self._root or Path.cwd() / "codeflow-jobs"
+        ws = (base / jid).resolve()
+        ws.mkdir(parents=True, exist_ok=True)
+        src = ws / "src"
+        src.mkdir(parents=True, exist_ok=True)
+        raw_zip = ws / "upload.zip"
+        raw_zip.write_bytes(zip_bytes)
+        with zipfile.ZipFile(raw_zip, "r") as zf:
+            zf.extractall(src)
+
+        out = ws / "out"
+        cfg = ScanConfig(
+            project_root=src,
+            output_path=out,
+            formats=cfg_template.formats,
+            depth=cfg_template.depth,
+            languages=cfg_template.languages,
+            entry=cfg_template.entry,
+            include=cfg_template.include,
+            exclude=cfg_template.exclude,
+            include_internal=cfg_template.include_internal,
+            async_mode=cfg_template.async_mode,
+            jobs=True,
+            runtime=cfg_template.runtime,
+            paths_override=cfg_template.paths_override,
+            business_rules=cfg_template.business_rules,
+            business_rules_sql=cfg_template.business_rules_sql,
+            business_rules_combined=cfg_template.business_rules_combined,
+        )
+        now = time.time()
+        cfg_dump = json.dumps(scan_config_dump(cfg), sort_keys=True)
+        assert self._conn is not None
+        with self._lock:
+            self._conn.execute(
+                """
+                INSERT INTO jobs (job_id, status, progress, current, workspace, zip_path, error, created_at, updated_at, config_json)
+                VALUES (?, ?, 0, '', ?, NULL, NULL, ?, ?, ?)
+                """,
+                (jid, "PENDING", str(ws), now, now, cfg_dump),
+            )
+            self._conn.commit()
+        return self.get(jid)  # type: ignore[return-value]
+
+    def get(self, job_id: str) -> CodeflowJobRecord | None:
+        assert self._conn is not None
+        with self._lock:
+            row = self._conn.execute("SELECT * FROM jobs WHERE job_id = ?", (job_id,)).fetchone()
+        if not row:
+            return None
+        return CodeflowJobRecord(
+            job_id=row["job_id"],
+            status=row["status"],
+            progress=row["progress"],
+            current=row["current"],
+            workspace=row["workspace"],
+            zip_path=row["zip_path"],
+            error=row["error"],
+            created_at=row["created_at"],
+            updated_at=row["updated_at"],
+        )
+
+    def update_progress(self, job_id: str, progress: int, current: str) -> None:
+        assert self._conn is not None
+        now = time.time()
+        with self._lock:
+            self._conn.execute(
+                "UPDATE jobs SET progress = ?, current = ?, updated_at = ? WHERE job_id = ?",
+                (progress, current, now, job_id),
+            )
+            self._conn.commit()
+
+    def mark_running(self, job_id: str) -> None:
+        self._set_status(job_id, "RUNNING")
+
+    def mark_completed(self, job_id: str, zip_path: Path | None) -> None:
+        assert self._conn is not None
+        now = time.time()
+        with self._lock:
+            self._conn.execute(
+                "UPDATE jobs SET status = ?, progress = 100, zip_path = ?, updated_at = ?, current = ? WHERE job_id = ?",
+                ("COMPLETED", str(zip_path) if zip_path else None, now, "completed", job_id),
+            )
+            self._conn.commit()
+
+    def mark_failed(self, job_id: str, err: str) -> None:
+        assert self._conn is not None
+        now = time.time()
+        with self._lock:
+            self._conn.execute(
+                "UPDATE jobs SET status = ?, error = ?, updated_at = ?, current = ? WHERE job_id = ?",
+                ("FAILED", err[:8000], now, "failed", job_id),
+            )
+            self._conn.commit()
+
+    def _set_status(self, job_id: str, status: str) -> None:
+        assert self._conn is not None
+        now = time.time()
+        with self._lock:
+            self._conn.execute(
+                "UPDATE jobs SET status = ?, updated_at = ? WHERE job_id = ?",
+                (status, now, job_id),
+            )
+            self._conn.commit()
+
+    def load_config(self, job_id: str) -> ScanConfig | None:
+        assert self._conn is not None
+        with self._lock:
+            row = self._conn.execute(
+                "SELECT config_json FROM jobs WHERE job_id = ?", (job_id,)
+            ).fetchone()
+        if not row:
+            return None
+        return scan_config_load(json.loads(row["config_json"]))
+
+    def run_job_thread(self, job_id: str) -> None:
+        def target() -> None:
+            try:
+                self.mark_running(job_id)
+                cfg = self.load_config(job_id)
+                if not cfg:
+                    self.mark_failed(job_id, "missing config")
+                    return
+                rec = self.get(job_id)
+                if not rec:
+                    return
+                ws_path = Path(rec.workspace)
+
+                def on_prog(p: int, cur: str) -> None:
+                    self.update_progress(job_id, p, cur)
+
+                lw = LoadedWorkspace(root=cfg.project_root, cleanup_dir=None)
+
+                self.update_progress(job_id, 10, "scan")
+                run_scan(cfg, workspace=lw)
+                on_prog(90, "zip")
+
+                zpath = ws_path / "output.zip"
+                self._zip_output(ws_path, cfg.output_path, zpath)
+                self.mark_completed(job_id, zpath)
+            except Exception as e:
+                self.mark_failed(job_id, str(e))
+
+        threading.Thread(target=target, daemon=True).start()
+
+    def _zip_output(self, workspace: Path, out_dir: Path, dest_zip: Path) -> None:
+        dest_zip.parent.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(dest_zip, "w", zipfile.ZIP_DEFLATED) as zf:
+            if out_dir.exists():
+                for p in sorted(out_dir.rglob("*")):
+                    if p.is_file():
+                        zf.write(p, p.relative_to(workspace).as_posix())
+
+
+def _default_sqlite_path() -> Path:
+    import tempfile
+
+    return Path(tempfile.gettempdir()) / "mdengine-codeflow-jobs" / "jobs.sqlite"

mdengine-0.7.0/src/md_generator/codeflow/api/main.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, Response, StreamingResponse
+
+from md_generator.codeflow.api.job_manager import CodeflowJobManager
+from md_generator.codeflow.api.schemas import merge_upload_options_json, options_to_scan_config
+from md_generator.codeflow.api.settings import CodeflowApiSettings, cors_list, sqlite_path_resolved
+from md_generator.codeflow.core.extractor import build_output_zip
+from md_generator.codeflow.core.run_config import ScanConfig
+
+try:
+    from md_generator.codeflow.mcp.server import build_mcp_stack
+
+    _mcp, _mcp_http = build_mcp_stack(mount_under_fastapi=True)
+except Exception:
+    _mcp = None  # type: ignore[misc]
+    _mcp_http = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    settings = CodeflowApiSettings()
+    ws = Path(settings.job_workspace_root) if settings.job_workspace_root else None
+    jobs = CodeflowJobManager(sqlite_path=sqlite_path_resolved(settings), workspace_root=ws)
+    app.state.settings = settings
+    app.state.jobs = jobs
+    if _mcp is not None:
+        async with _mcp.session_manager.run():
+            yield
+    else:
+        yield
+    jobs.close()
+
+
+app = FastAPI(title="codeflow-to-md", lifespan=lifespan)
+if _mcp_http is not None:
+    app.mount("/mcp", _mcp_http)
+
+_bootstrap = CodeflowApiSettings()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=cors_list(_bootstrap),
+    allow_credentials="*" not in cors_list(_bootstrap),
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/health")
+async def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.post("/analyze")
+async def analyze_upload(
+    request: Request,
+    file: UploadFile = File(...),
+    options_json: str | None = Form(default=None),
+) -> dict[str, str]:
+    """Upload a ZIP of source code; returns ``job_id`` for async processing."""
+    settings: CodeflowApiSettings = request.app.state.settings
+    jobs: CodeflowJobManager = request.app.state.jobs
+    raw = await file.read()
+    max_b = max(1, settings.max_upload_zip_mb) * 1024 * 1024
+    if len(raw) > max_b:
+        raise HTTPException(status_code=413, detail=f"ZIP exceeds CODEFLOW_MAX_UPLOAD_ZIP_MB ({settings.max_upload_zip_mb})")
+    try:
+        opts = merge_upload_options_json(options_json)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    # template: output path overwritten in job manager
+    tmp_src = Path(".")
+    cfg_tpl = options_to_scan_config(tmp_src, "out", opts)
+    try:
+        rec = jobs.create_zip_job(raw, cfg_tpl)
+        jobs.run_job_thread(rec.job_id)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    return {"job_id": rec.job_id}
+
+
+@app.get("/status/{job_id}")
+async def job_status(request: Request, job_id: str) -> dict:
+    jobs: CodeflowJobManager = request.app.state.jobs
+    rec = jobs.get(job_id)
+    if not rec:
+        raise HTTPException(404, detail="Unknown job_id")
+    return rec.to_api_dict()
+
+
+@app.get("/result/{job_id}")
+async def job_result(request: Request, job_id: str) -> FileResponse:
+    jobs: CodeflowJobManager = request.app.state.jobs
+    rec = jobs.get(job_id)
+    if not rec:
+        raise HTTPException(404, detail="Unknown job_id")
+    if rec.status != "COMPLETED" or not rec.zip_path:
+        raise HTTPException(400, detail="Job is not ready")
+    path = Path(rec.zip_path)
+    if not path.is_file():
+        raise HTTPException(400, detail="ZIP missing on disk")
+    return FileResponse(path, media_type="application/zip", filename="codeflow-output.zip")
+
+
+@app.post("/analyze/sync")
+async def analyze_sync(
+    request: Request,
+    file: UploadFile = File(...),
+    options_json: str | None = Form(default=None),
+) -> Response:
+    """Small ZIP → immediate ZIP response (bounded by ``CODEFLOW_MAX_SYNC_ZIP_MB``)."""
+    settings: CodeflowApiSettings = request.app.state.settings
+    raw = await file.read()
+    max_up = max(1, settings.max_upload_zip_mb) * 1024 * 1024
+    if len(raw) > max_up:
+        raise HTTPException(status_code=413, detail="ZIP too large")
+    try:
+        opts = merge_upload_options_json(options_json)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    import tempfile
+
+    td = Path(tempfile.mkdtemp(prefix="codeflow-sync-"))
+    src = td / "src"
+    src.mkdir(parents=True, exist_ok=True)
+    zin = td / "in.zip"
+    zin.write_bytes(raw)
+    import zipfile
+
+    with zipfile.ZipFile(zin, "r") as zf:
+        zf.extractall(src)
+    cfg = options_to_scan_config(src, "out", opts)
+    try:
+        data = build_output_zip(cfg, workspace_root=src)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    max_b = settings.max_sync_zip_mb * 1024 * 1024
+    if len(data) > max_b:
+        raise HTTPException(status_code=413, detail=f"Output exceeds CODEFLOW_MAX_SYNC_ZIP_MB ({settings.max_sync_zip_mb}); use POST /analyze")
+    return Response(
+        content=data,
+        media_type="application/zip",
+        headers={"Content-Disposition": 'attachment; filename="codeflow-output.zip"'},
+    )
+
+
+@app.get("/analyze/job/{job_id}/events")
+async def job_events(request: Request, job_id: str) -> StreamingResponse:
+    from md_generator.codeflow.api.sse import format_sse
+
+    jobs: CodeflowJobManager = request.app.state.jobs
+
+    async def gen():
+        rec = jobs.get(job_id)
+        if not rec:
+            yield format_sse("job_failed", {"job_id": job_id, "error": "unknown job_id"}).encode("utf-8")
+            return
+        yield format_sse("job_started", {"job_id": job_id}).encode("utf-8")
+        last_progress = -1
+        while True:
+            rec = jobs.get(job_id)
+            if not rec:
+                yield format_sse("job_failed", {"job_id": job_id, "error": "job disappeared"}).encode("utf-8")
+                return
+            if rec.progress != last_progress or rec.current:
+                last_progress = rec.progress
+                yield format_sse(
+                    "progress_update",
+                    {"progress": rec.progress, "current": rec.current},
+                ).encode("utf-8")
+            if rec.status == "COMPLETED":
+                yield format_sse("job_completed", {"job_id": job_id, "zip_path": rec.zip_path}).encode("utf-8")
+                return
+            if rec.status == "FAILED":
+                yield format_sse("job_failed", {"job_id": job_id, "error": rec.error or "unknown"}).encode("utf-8")
+                return
+            await asyncio.sleep(0.4)
+
+    return StreamingResponse(gen(), media_type="text/event-stream")

mdengine-0.7.0/src/md_generator/codeflow/api/mcp_server.py

@@ -0,0 +1,16 @@
+"""Standalone MCP server for codeflow (stdio)."""
+
+from __future__ import annotations
+
+import asyncio
+
+
+def main() -> None:
+    from md_generator.codeflow.mcp.server import build_mcp_stack
+
+    mcp, _ = build_mcp_stack(mount_under_fastapi=False)
+    asyncio.run(mcp.run_stdio_async())
+
+
+if __name__ == "__main__":
+    main()

mdengine-0.7.0/src/md_generator/codeflow/api/run.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import os
+
+
+def main() -> None:
+    import uvicorn
+
+    host = os.environ.get("CODEFLOW_TO_MD_HOST", "127.0.0.1")
+    port = int(os.environ.get("CODEFLOW_TO_MD_PORT", "8016"))
+    uvicorn.run("md_generator.codeflow.api.main:app", host=host, port=port, reload=False)
+
+
+if __name__ == "__main__":
+    main()