@guanlin4924/devflow-pi 0.1.62 → 0.1.64

package/plugins/devflow-intel/skills/workflow-code-index/scripts/code_index.py

@@ -3,6 +3,7 @@ import argparse
 import contextlib
 import json
 import os
+import re
 import shutil
 import sqlite3
 import subprocess
@@ -59,12 +60,14 @@ def _index_lock(output: Path, exclusive: bool):
 
 def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int], workspace_state: Dict[str, object]) -> None:
     generation = str(uuid.uuid4())
+    immutable_relative = f"snapshots/{generation}"
     snapshot = {
         "schemaVersion": 1,
         "generation": generation,
         "generatedAt": datetime.now(timezone.utc).isoformat(),
         "counts": counts,
         "workspace": workspace_state,
+        "immutablePath": immutable_relative,
         "artifacts": [*INDEX_FILES.values(), "index.sqlite", *MARKDOWN_FILES],
     }
     snapshot_path = staging / SNAPSHOT_FILE
@@ -72,9 +75,21 @@ def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int], works
     with snapshot_path.open("rb") as handle:
         os.fsync(handle.fileno())
 
+    snapshots = output / "snapshots"
+    snapshots.mkdir(parents=True, exist_ok=True)
+    immutable = snapshots / generation
+    os.replace(staging, immutable)
+
+    # Existing consumers keep reading the root paths. They are projections of
+    # one immutable generation; SNAPSHOT.json is switched last as the commit
+    # marker so readers never accept an uncommitted generation.
     for name in snapshot["artifacts"]:
-        os.replace(staging / name, output / name)
-    os.replace(snapshot_path, output / SNAPSHOT_FILE)
+        source = immutable / name
+        temporary = output / f".{name}.{generation}.tmp"
+        shutil.copy2(source, temporary)
+        os.replace(temporary, output / name)
+    shutil.copy2(immutable / SNAPSHOT_FILE, output / f".{SNAPSHOT_FILE}.{generation}.tmp")
+    os.replace(output / f".{SNAPSHOT_FILE}.{generation}.tmp", output / SNAPSHOT_FILE)
     directory_fd = os.open(output, os.O_RDONLY)
     try:
         os.fsync(directory_fd)
@@ -90,6 +105,12 @@ def _workspace_state(root: Path, files: List[dict], changed: Set[str]) -> Dict[s
         "contentManifestHash": source_manifest_hash,
         "indexedPathsHash": _hash_lines(indexed_paths),
         "dirtyPathsAtBuild": sorted(changed),
+        "extractors": sorted(set(record.get("parser", "unknown") for record in files)),
+        "capabilities": {
+            "python-ast@1": {"scope": "exact syntax tree", "targets": "lexical names; dynamic dispatch unresolved"},
+            "structured-scope@1": {"scope": "inferred lexical braces/end blocks", "targets": "name-only heuristic"},
+            "generic-text@2": {"scope": "file-level", "targets": "heuristic only"},
+        },
     }
 
 
@@ -152,6 +173,15 @@ def main(argv=None) -> int:
     query.add_argument("--index", default=".planning/code-index", help="Index directory.")
     query.add_argument("--term", required=True, help="Search term.")
     query.add_argument("--limit", type=int, default=20)
+    query.add_argument("--snapshot", help="Immutable generation id. Historical queries do not require current workspace freshness.")
+
+    relations = sub.add_parser("relations", help="Traverse resolved relations in a fixed snapshot.")
+    relations.add_argument("--index", default=".planning/code-index")
+    relations.add_argument("--object", required=True, help="Source symbol id.")
+    relations.add_argument("--depth", type=int, default=3)
+    relations.add_argument("--limit", type=int, default=100)
+    relations.add_argument("--snapshot")
+    relations.add_argument("--include-heuristic", action="store_true")
 
     args = parser.parse_args(argv)
     if args.command == "scan":
@@ -162,6 +192,8 @@ def main(argv=None) -> int:
         return command_audit(args)
     if args.command == "query":
         return command_query(args)
+    if args.command == "relations":
+        return command_relations(args)
     return 2
 
 
@@ -188,11 +220,11 @@ def command_scan(args) -> int:
                 all_files = [path for path in all_files if _workspace_rel(root, path) in changed]
             manifests = [path for path in all_files if path.name in {"package.json", "go.mod", "Cargo.toml", "pyproject.toml", "requirements.txt", "composer.json", "pubspec.yaml"}]
             adapters = registry.adapters_for(codebase, all_files, manifests)
-            adapter = adapters[0]
             for path in all_files:
                 rel_path = _workspace_rel(root, path)
                 if rel_path in indexed_paths:
                     continue
+                adapter = adapters[-1]
                 try:
                     text = path.read_text(encoding="utf-8", errors="ignore")
                     content_hash = file_sha256(path)
@@ -204,8 +236,10 @@ def command_scan(args) -> int:
                         "size_bytes": path.stat().st_size,
                         "content_hash": content_hash,
                         "indexed_at": datetime.now(timezone.utc).isoformat(),
-                        "parser": adapter.parser_id,
+                        "parser": "pending",
                     }
+                    adapter = registry.adapter_for_file(codebase, file_record)
+                    file_record["parser"] = adapter.parser_id
                     result = adapter.parse_file(codebase, file_record, text)
                     files.append(file_record)
                     symbols.extend(result.symbols)
@@ -261,13 +295,14 @@ def command_validate(args) -> int:
 def command_query(args) -> int:
     output = Path(args.index).resolve()
     with _index_lock(output, exclusive=False):
-        index = output / "index.sqlite"
+        selected = _selected_generation(output, getattr(args, "snapshot", None))
+        index = selected / "index.sqlite"
         if not index.exists():
             print(f"Missing index: {index}", file=sys.stderr)
             return 1
-        snapshot = _load_snapshot(output)
-        files = read_jsonl(output / INDEX_FILES["files"])
-        if not _query_is_fresh(output.parent.parent, snapshot, files):
+        snapshot = _load_snapshot(selected)
+        files = read_jsonl(selected / INDEX_FILES["files"])
+        if not getattr(args, "snapshot", None) and not _query_is_fresh(output.parent.parent, snapshot, files):
             print("Stale code index: refresh required before query.", file=sys.stderr)
             return 1
         conn = sqlite3.connect(str(index))
@@ -302,6 +337,49 @@ def command_query(args) -> int:
     return 0
 
 
+def command_relations(args) -> int:
+    output = Path(args.index).resolve()
+    depth = max(0, min(args.depth, 20)); limit = max(1, min(args.limit, 1000))
+    with _index_lock(output, exclusive=False):
+        selected = _selected_generation(output, getattr(args, "snapshot", None))
+        snapshot = _load_snapshot(selected); files = read_jsonl(selected / INDEX_FILES["files"])
+        if not getattr(args, "snapshot", None) and not _query_is_fresh(output.parent.parent, snapshot, files):
+            print("Stale code index: refresh required before query.", file=sys.stderr); return 1
+        conn = sqlite3.connect(str(selected / "index.sqlite")); conn.row_factory = sqlite3.Row
+        try:
+            if depth == 0:
+                print(json.dumps({"_meta": {"snapshot": snapshot.get("generation"), "depthLimit": 0, "resultLimit": limit, "truncated": False}}, ensure_ascii=False, sort_keys=True))
+                return 0
+            confidence = "" if args.include_heuristic else "AND r.confidence != 'heuristic'"
+            rows = conn.execute(f"""
+              WITH RECURSIVE graph(from_id,relation_type,to_id,to_external,evidence_path,evidence_line,confidence,depth,visited) AS (
+                SELECT r.from_id,r.relation_type,r.to_id,r.to_external,r.evidence_path,r.evidence_line,r.confidence,1,',' || r.from_id || ',' || COALESCE(r.to_id,'') || ','
+                FROM relations r WHERE r.from_id=? {confidence}
+                UNION ALL
+                SELECT r.from_id,r.relation_type,r.to_id,r.to_external,r.evidence_path,r.evidence_line,r.confidence,g.depth+1,g.visited || COALESCE(r.to_id,'') || ','
+                FROM graph g JOIN relations r ON r.from_id=g.to_id
+                WHERE g.depth < ? AND r.to_id IS NOT NULL {confidence} AND instr(g.visited, ',' || r.to_id || ',')=0
+              ) SELECT * FROM graph ORDER BY depth,from_id,relation_type,to_id LIMIT ?
+            """, (args.object, depth, limit + 1)).fetchall()
+            truncated = len(rows) > limit
+            for row in rows[:limit]: print(json.dumps(dict(row), ensure_ascii=False, sort_keys=True))
+            print(json.dumps({"_meta": {"snapshot": snapshot.get("generation"), "depthLimit": depth, "resultLimit": limit, "truncated": truncated}}, ensure_ascii=False, sort_keys=True))
+        finally: conn.close()
+    return 0
+
+
+def _selected_generation(output: Path, generation: str | None) -> Path:
+    if not generation:
+        return output
+    if not re.fullmatch(r"[0-9a-f-]{36}", generation, re.I):
+        raise ValueError("invalid snapshot generation")
+    selected = output / "snapshots" / generation
+    snapshot = _load_snapshot(selected)
+    if snapshot.get("generation") != generation:
+        raise ValueError(f"unknown snapshot generation: {generation}")
+    return selected
+
+
 def _load_snapshot(output: Path) -> Dict[str, object]:
     path = output / SNAPSHOT_FILE
     if not path.exists():
@@ -318,6 +396,18 @@ def _query_is_fresh(root: Path, snapshot: Dict[str, object], files: List[dict])
     indexed_manifest = _hash_lines(f"{record['path']}\0{record['content_hash']}" for record in files)
     if workspace.get("contentManifestHash") != indexed_manifest:
         return False
+    for record in files:
+        source = (root / record["path"]).resolve()
+        try:
+            if not source.is_file() or file_sha256(source) != record["content_hash"]:
+                return False
+        except OSError:
+            return False
+    indexed_paths = sorted(record["path"] for record in files)
+    if not any(path.startswith("../") for path in indexed_paths):
+        current_paths = sorted(_workspace_rel(root, item) for item in scan_files(root))
+        if _hash_lines(current_paths) != workspace.get("indexedPathsHash"):
+            return False
     return True
 
 
@@ -432,13 +522,21 @@ def _resolve_relations(symbols: List[dict], relations: List[dict]) -> List[dict]
             continue
         name = relation["to_external"][5:]
         candidates = by_name.get((source["codebase"], name), [])
-        if len(candidates) == 1:
+        resolution = relation.get("metadata", {}).get("resolution")
+        may_resolve = resolution == "lexical_name" or relation.get("metadata", {}).get("allow_unique_name_resolution") is True
+        if len(candidates) == 1 and may_resolve:
             upgraded = dict(relation)
             upgraded["to_id"] = candidates[0]["id"]
             upgraded["confidence"] = "inferred" if upgraded["confidence"] == "heuristic" else upgraded["confidence"]
             upgraded.setdefault("metadata", {})["resolution"] = "unique_symbol_name_in_codebase"
             resolved.append(upgraded)
         else:
+            if candidates:
+                unresolved = dict(relation)
+                unresolved.setdefault("metadata", {})["resolution"] = "ambiguous_symbol_name"
+                unresolved["metadata"]["candidate_ids"] = sorted(candidate["id"] for candidate in candidates)
+                resolved.append(unresolved)
+                continue
             resolved.append(relation)
     return resolved
 

package/src/cli.ts

@@ -11,7 +11,7 @@ import { projectSessionDir } from "./paths.ts";
 function usage(): string {
   return [
     "Usage:",
-    "  devflow-pi init [project]",
+    "  devflow-pi init [project] [--scan]",
     "  devflow-pi doctor [project]",
     "  devflow-pi usage [project]",
     "  devflow-pi [project] [--resume [session-id]] [--prompt <text>] [--mcp] [--yolo]",
@@ -47,12 +47,22 @@ async function main(): Promise<void> {
     return;
   }
   if (command === "init") {
-    const requested = args[1] ? path.resolve(args[1]) : process.cwd();
+    const projectArgument = args[1] && !args[1].startsWith("-") ? args[1] : undefined;
+    const requested = projectArgument ? path.resolve(projectArgument) : process.cwd();
     const root = await resolveProjectRoot(requested, { explicit: requested, allowUninitialized: true });
     const { context, created } = await initializeProject(root);
     console.log(`${created ? "Initialized" : "Already initialized"}: ${context.root}`);
     console.log(`projectId: ${context.manifest.projectId}`);
+    console.log(`workspaceId: ${context.workspaceId}`);
+    console.log(`database: ${context.controlDatabasePath}`);
     console.log(`planning: ${context.planningRoot}`);
+    if (args.includes("--scan")) {
+      const { runProjectInitialization } = await import("./project-initializer.ts");
+      const result = await runProjectInitialization(context, { requestId: option(args, "--request-id") });
+      console.log(`initializationRun: ${result.runId}`);
+      console.log(`contextSnapshot: ${result.snapshotId}`);
+      console.log(`completeness: ${result.completeness}`);
+    }
     return;
   }
   const positionalProject = command && !["doctor", "usage"].includes(command) && !command.startsWith("-") ? command : undefined;

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.62";
+export const PRODUCT_VERSION = "0.1.64";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";