@dailephd/my-dev-kit 1.0.0

package/dist/cli.js

@@ -0,0 +1,2611 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/indexing/runIndexCommand.ts
+import * as fs4 from "fs";
+import * as path9 from "path";
+
+// src/graph/codeGraphTypes.ts
+var CODE_GRAPH_SCHEMA_VERSION = "1.0.0";
+
+// src/graph/buildCodeGraph.ts
+function buildCodeGraph(options) {
+  const nodes = [];
+  const edges = [];
+  const symbolIds = /* @__PURE__ */ new Map();
+  for (const file of options.symbolIndex.files) {
+    const fileId = fileNodeId(file.path);
+    nodes.push({
+      id: fileId,
+      kind: "file",
+      label: basename(file.path),
+      path: file.path,
+      language: file.language
+    });
+    for (const symbol of file.symbols) {
+      const symbolId = symbolNodeId(file.path, symbol.name);
+      symbolIds.set(symbolKey(file.path, symbol), symbolId);
+      nodes.push({
+        id: symbolId,
+        kind: "symbol",
+        label: symbol.name,
+        path: file.path,
+        symbolName: symbol.name,
+        symbolKind: symbol.kind,
+        line: symbol.location.line,
+        exported: symbol.exported
+      });
+      edges.push({
+        id: edgeId(fileId, "defines", symbolId),
+        source: fileId,
+        target: symbolId,
+        kind: "defines"
+      });
+      if (symbol.exported) {
+        edges.push({
+          id: edgeId(fileId, "exports", symbolId),
+          source: fileId,
+          target: symbolId,
+          kind: "exports"
+        });
+      }
+    }
+  }
+  for (const dep of options.symbolIndex.graph?.fileDeps ?? []) {
+    const source = fileNodeId(dep.from);
+    const target = fileNodeId(dep.to);
+    edges.push({
+      id: edgeId(source, "imports", target),
+      source,
+      target,
+      kind: dep.kind === "import" ? "imports" : "depends-on",
+      label: dep.kind
+    });
+  }
+  for (const call of options.callGraph?.edges ?? []) {
+    if (!call.callee.file) continue;
+    const source = symbolIds.get(`${call.caller.file}#${call.caller.name}@${call.caller.line}`);
+    const target = findSymbolId(symbolIds, call.callee.file, call.callee.name);
+    if (!source || !target) continue;
+    edges.push({
+      id: `${edgeId(source, "calls", target)}@${call.callLine}`,
+      source,
+      target,
+      kind: "calls"
+    });
+  }
+  sortById(nodes);
+  sortById(edges);
+  const fileNodeCount = nodes.filter((node) => node.kind === "file").length;
+  const symbolNodeCount = nodes.filter((node) => node.kind === "symbol").length;
+  return {
+    artifactKind: "code-graph",
+    schemaVersion: CODE_GRAPH_SCHEMA_VERSION,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodes,
+    edges,
+    summary: {
+      nodeCount: nodes.length,
+      edgeCount: edges.length,
+      fileNodeCount,
+      symbolNodeCount
+    }
+  };
+}
+function fileNodeId(filePath) {
+  return `file:${filePath}`;
+}
+function symbolNodeId(filePath, name) {
+  return `symbol:${filePath}#${name}`;
+}
+function symbolKey(filePath, symbol) {
+  return `${filePath}#${symbol.name}@${symbol.location.line}`;
+}
+function findSymbolId(symbolIds, filePath, name) {
+  const prefix = `${filePath}#${name}@`;
+  for (const [key, id] of symbolIds) {
+    if (key.startsWith(prefix)) return id;
+  }
+  return void 0;
+}
+function edgeId(source, kind, target) {
+  return `${source}--${kind}-->${target}`;
+}
+function basename(filePath) {
+  return filePath.split("/").at(-1) ?? filePath;
+}
+function sortById(items) {
+  items.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+// src/io/pathUtils.ts
+import * as path from "path";
+function toForwardSlash(p) {
+  return p.replace(/\\/g, "/");
+}
+function isInsideRoot(root, target) {
+  const absRoot = path.resolve(root);
+  const absTarget = path.resolve(target);
+  const rel = path.relative(absRoot, absTarget);
+  return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+
+// src/symbol-index/builder.ts
+import * as fs2 from "fs";
+
+// src/symbol-index/graphBuilder.ts
+import * as ts from "typescript";
+import * as path2 from "path";
+
+// src/symbol-index/types.ts
+var SCHEMA_VERSION = "2";
+
+// src/symbol-index/graphBuilder.ts
+function createCallGraph(edges, buildTime = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    buildTime,
+    edgeCount: edges.length,
+    edges
+  };
+}
+function extractTypeScriptCallGraphEdges(files) {
+  const edges = [];
+  const exportMap = buildExportMap(files);
+  for (const { filePath, sourceText } of files) {
+    const sourceFile = ts.createSourceFile(
+      filePath,
+      sourceText,
+      ts.ScriptTarget.Latest,
+      true
+    );
+    const importedNames = buildImportedNameMap(sourceFile, filePath, exportMap);
+    extractEdges(sourceFile, filePath, importedNames, edges);
+  }
+  return edges;
+}
+function extractEdges(sourceFile, filePath, importedNames, edges) {
+  function walk(node, currentCaller) {
+    const newCaller = resolveCaller(node, sourceFile, filePath, currentCaller);
+    const activeCaller = newCaller ?? currentCaller;
+    if (ts.isCallExpression(node) && activeCaller) {
+      const calleeName = calleeNameOf(node.expression);
+      if (calleeName && calleeName !== "<computed>") {
+        const callLine = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+        const calleeFile = resolveCalleeFile(calleeName, importedNames);
+        edges.push({
+          caller: {
+            file: activeCaller.file,
+            name: activeCaller.name,
+            line: activeCaller.line
+          },
+          callee: { file: calleeFile, name: calleeName },
+          callLine
+        });
+      }
+    }
+    ts.forEachChild(node, (child) => walk(child, activeCaller));
+  }
+  walk(sourceFile, null);
+}
+function resolveCaller(node, sourceFile, filePath, parent) {
+  const lineOf = (n) => sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)).line + 1;
+  if (ts.isFunctionDeclaration(node) && node.name) {
+    return { file: filePath, name: node.name.text, line: lineOf(node) };
+  }
+  if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
+    const ownerName = parent?.name ? `${parent.name}.${node.name.text}` : node.name.text;
+    return { file: filePath, name: ownerName, line: lineOf(node) };
+  }
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+      return { file: filePath, name: node.parent.name.text, line: lineOf(node) };
+    }
+  }
+  return null;
+}
+function calleeNameOf(expr) {
+  if (ts.isIdentifier(expr)) return expr.text;
+  if (ts.isPropertyAccessExpression(expr)) {
+    return calleeNameOf(expr.expression) + "." + expr.name.text;
+  }
+  return "<computed>";
+}
+function resolveCalleeFile(calleeName, importedNames) {
+  if (importedNames.has(calleeName)) return importedNames.get(calleeName);
+  const base = calleeName.split(".")[0];
+  if (importedNames.has(base)) return importedNames.get(base);
+  return null;
+}
+function buildExportMap(files) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { filePath, sourceText } of files) {
+    const sf = ts.createSourceFile(
+      filePath,
+      sourceText,
+      ts.ScriptTarget.Latest,
+      true
+    );
+    ts.forEachChild(sf, (node) => {
+      if (hasExportKeyword(node)) {
+        const name = declaredName(node);
+        if (name) map.set(name, filePath);
+      }
+      if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {
+        for (const el of node.exportClause.elements) {
+          map.set(el.name.text, filePath);
+        }
+      }
+    });
+  }
+  return map;
+}
+function buildImportedNameMap(sourceFile, filePath, exportMap) {
+  const map = /* @__PURE__ */ new Map();
+  const fileDir = path2.dirname(filePath);
+  ts.forEachChild(sourceFile, (node) => {
+    if (!ts.isImportDeclaration(node)) return;
+    const specifier = node.moduleSpecifier.text;
+    const resolvedPath = specifier.startsWith(".") ? toForwardSlash(path2.join(fileDir, specifier)) : null;
+    if (!node.importClause) return;
+    const clause = node.importClause;
+    if (clause.name) {
+      map.set(clause.name.text, resolvedPath ?? null);
+    }
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+      for (const el of clause.namedBindings.elements) {
+        const resolvedViaExport = exportMap.get(el.name.text) ?? resolvedPath ?? null;
+        map.set(el.name.text, resolvedViaExport);
+      }
+    }
+    if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+      map.set(clause.namedBindings.name.text, resolvedPath ?? null);
+    }
+  });
+  return map;
+}
+function hasExportKeyword(node) {
+  const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function declaredName(node) {
+  if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+    return node.name?.text ?? null;
+  }
+  if (ts.isVariableStatement(node)) {
+    const first = node.declarationList.declarations[0];
+    if (first && ts.isIdentifier(first.name)) return first.name.text;
+  }
+  return null;
+}
+
+// src/languages/registry.ts
+import * as path6 from "path";
+
+// src/languages/typescript/adapter.ts
+import * as path4 from "path";
+
+// src/symbol-index/symbolExtractor.ts
+import * as ts2 from "typescript";
+import * as path3 from "path";
+function extractFromSource(filePath, sourceText) {
+  const language = languageOf(filePath);
+  const scriptKind = language === "typescript" ? filePath.endsWith(".tsx") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS : ts2.ScriptKind.JS;
+  const sourceFile = ts2.createSourceFile(
+    filePath,
+    sourceText,
+    ts2.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    scriptKind
+  );
+  const lineCount = sourceText.split("\n").length;
+  const imports = [];
+  const exports = [];
+  const symbols = [];
+  const reExportSpecifiers = [];
+  const exportAllSpecifiers = [];
+  ts2.forEachChild(sourceFile, (node) => {
+    visitTopLevel(
+      node,
+      sourceFile,
+      filePath,
+      imports,
+      exports,
+      symbols,
+      reExportSpecifiers,
+      exportAllSpecifiers
+    );
+  });
+  return {
+    language,
+    lineCount,
+    imports: dedup(imports),
+    exports: dedup(exports),
+    symbols,
+    reExportSpecifiers: dedup(reExportSpecifiers),
+    exportAllSpecifiers: dedup(exportAllSpecifiers)
+  };
+}
+function visitTopLevel(node, sourceFile, filePath, imports, exports, symbols, reExportSpecifiers, exportAllSpecifiers) {
+  if (ts2.isImportDeclaration(node)) {
+    const specifier = node.moduleSpecifier.text;
+    imports.push(specifier);
+    return;
+  }
+  if (ts2.isExportDeclaration(node)) {
+    const specifier = node.moduleSpecifier ? node.moduleSpecifier.text : null;
+    if (node.exportClause && ts2.isNamedExports(node.exportClause)) {
+      for (const el of node.exportClause.elements) {
+        exports.push(el.name.text);
+      }
+      if (specifier) reExportSpecifiers.push(specifier);
+    } else if (!node.exportClause && specifier) {
+      exportAllSpecifiers.push(specifier);
+    }
+    return;
+  }
+  if (ts2.isFunctionDeclaration(node) && node.name) {
+    const name = node.name.text;
+    const exp = hasExportKeyword2(node);
+    if (exp) exports.push(name);
+    symbols.push({
+      name,
+      kind: "function",
+      location: locationOf(node, sourceFile, filePath),
+      exported: exp,
+      signature: briefSignature(node, sourceFile)
+    });
+    return;
+  }
+  if (ts2.isClassDeclaration(node) && node.name) {
+    const name = node.name.text;
+    const exp = hasExportKeyword2(node);
+    if (exp) exports.push(name);
+    symbols.push({
+      name,
+      kind: "class",
+      location: locationOf(node, sourceFile, filePath),
+      exported: exp,
+      signature: briefSignature(node, sourceFile)
+    });
+    return;
+  }
+  if (ts2.isInterfaceDeclaration(node)) {
+    const name = node.name.text;
+    const exp = hasExportKeyword2(node);
+    if (exp) exports.push(name);
+    symbols.push({
+      name,
+      kind: "interface",
+      location: locationOf(node, sourceFile, filePath),
+      exported: exp,
+      signature: briefSignature(node, sourceFile)
+    });
+    return;
+  }
+  if (ts2.isTypeAliasDeclaration(node)) {
+    const name = node.name.text;
+    const exp = hasExportKeyword2(node);
+    if (exp) exports.push(name);
+    symbols.push({
+      name,
+      kind: "type",
+      location: locationOf(node, sourceFile, filePath),
+      exported: exp,
+      signature: briefSignature(node, sourceFile)
+    });
+    return;
+  }
+  if (ts2.isEnumDeclaration(node)) {
+    const name = node.name.text;
+    const exp = hasExportKeyword2(node);
+    if (exp) exports.push(name);
+    symbols.push({
+      name,
+      kind: "enum",
+      location: locationOf(node, sourceFile, filePath),
+      exported: exp,
+      signature: briefSignature(node, sourceFile)
+    });
+    return;
+  }
+  if (ts2.isVariableStatement(node)) {
+    const exp = hasExportKeyword2(node);
+    const isConst = !!(node.declarationList.flags & ts2.NodeFlags.Const);
+    const kind = isConst ? "const" : "variable";
+    for (const decl of node.declarationList.declarations) {
+      if (ts2.isIdentifier(decl.name)) {
+        const name = decl.name.text;
+        if (exp) exports.push(name);
+        symbols.push({
+          name,
+          kind,
+          location: locationOf(decl, sourceFile, filePath),
+          exported: exp,
+          signature: briefSignature(node, sourceFile)
+        });
+      }
+    }
+    return;
+  }
+}
+function hasExportKeyword2(node) {
+  const mods = ts2.canHaveModifiers(node) ? ts2.getModifiers(node) : void 0;
+  return mods?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword) ?? false;
+}
+function locationOf(node, sourceFile, filePath) {
+  const { line } = sourceFile.getLineAndCharacterOfPosition(
+    node.getStart(sourceFile)
+  );
+  return { file: filePath, line: line + 1 };
+}
+function briefSignature(node, sourceFile) {
+  const text = node.getText(sourceFile);
+  const firstLine = text.split("\n")[0].trim();
+  return firstLine.length > 120 ? firstLine.slice(0, 117) + "..." : firstLine;
+}
+function languageOf(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  if (ext === ".ts" || ext === ".tsx") return "typescript";
+  return "javascript";
+}
+function dedup(arr) {
+  return [...new Set(arr)];
+}
+
+// src/languages/typescript/adapter.ts
+var TypeScriptAdapter = class {
+  extensions = [".ts", ".tsx", ".js", ".jsx"];
+  supportsCallGraph = true;
+  extractFromSource(filePath, sourceText) {
+    return extractFromSource(filePath, sourceText);
+  }
+  extractCallGraphEdges(files) {
+    return extractTypeScriptCallGraphEdges(files);
+  }
+  resolveImportToFile(specifier, importingFile, knownFiles) {
+    if (!specifier.startsWith(".")) return null;
+    const fromDir = toForwardSlash(path4.dirname(importingFile));
+    const base = toForwardSlash(path4.join(fromDir, specifier));
+    const knownSet = new Set(knownFiles);
+    if (knownSet.has(base)) return base;
+    for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+      const candidate = base + ext;
+      if (knownSet.has(candidate)) return candidate;
+    }
+    for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+      const candidate = base + "/index" + ext;
+      if (knownSet.has(candidate)) return candidate;
+    }
+    return null;
+  }
+};
+
+// src/languages/python/adapter.ts
+import { spawnSync } from "child_process";
+import * as path5 from "path";
+var EXTRACT_SYMBOLS_PY = `
+import sys, ast, json
+
+def main():
+    source = sys.stdin.read()
+    file_path = sys.argv[1] if len(sys.argv) > 1 else "<unknown>"
+    try:
+        tree = ast.parse(source, filename=file_path)
+    except SyntaxError as e:
+        sys.stdout.write(json.dumps({"error": "SyntaxError", "message": str(e), "lineno": e.lineno or 0}))
+        return
+    except Exception as e:
+        sys.stdout.write(json.dumps({"error": "ParseError", "message": str(e)}))
+        return
+
+    source_lines = source.splitlines()
+
+    def get_sig(lineno):
+        idx = lineno - 1
+        return source_lines[idx].strip()[:120] if 0 <= idx < len(source_lines) else ""
+
+    def decorator_names(dl):
+        names = []
+        for d in dl:
+            if isinstance(d, ast.Name): names.append(d.id)
+            elif isinstance(d, ast.Attribute): names.append(d.attr)
+            elif isinstance(d, ast.Call):
+                func = d.func
+                if isinstance(func, ast.Name): names.append(func.id)
+                elif isinstance(func, ast.Attribute): names.append(func.attr)
+        return names
+
+    dunder_all = None
+    for node in tree.body:
+        if isinstance(node, ast.Assign):
+            for t in node.targets:
+                if isinstance(t, ast.Name) and t.id == "__all__":
+                    if isinstance(node.value, (ast.List, ast.Tuple)):
+                        try:
+                            dunder_all = [e.value for e in node.value.elts if isinstance(e, ast.Constant) and isinstance(e.value, str)]
+                        except Exception:
+                            dunder_all = None
+
+    def is_exported(name):
+        if dunder_all is not None: return name in dunder_all
+        return not name.startswith("_")
+
+    def is_all_caps(name):
+        alpha = [c for c in name if c.isalpha()]
+        return len(alpha) > 0 and all(c.isupper() for c in alpha)
+
+    def has_final(ann):
+        if ann is None: return False
+        if isinstance(ann, ast.Name) and ann.id == "Final": return True
+        if isinstance(ann, ast.Subscript):
+            v = ann.value
+            if isinstance(v, ast.Name) and v.id == "Final": return True
+            if isinstance(v, ast.Attribute) and v.attr == "Final": return True
+        if isinstance(ann, ast.Attribute) and ann.attr == "Final": return True
+        return False
+
+    symbols = []
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            name = node.name
+            symbols.append({"name": name, "kind": "function", "line": node.lineno,
+                "end_line": getattr(node, "end_lineno", None),
+                "exported": is_exported(name), "signature": get_sig(node.lineno),
+                "decorators": decorator_names(node.decorator_list)})
+        elif isinstance(node, ast.ClassDef):
+            name = node.name
+            symbols.append({"name": name, "kind": "class", "line": node.lineno,
+                "end_line": getattr(node, "end_lineno", None),
+                "exported": is_exported(name), "signature": get_sig(node.lineno),
+                "decorators": decorator_names(node.decorator_list)})
+        elif isinstance(node, ast.Assign):
+            for t in node.targets:
+                if isinstance(t, ast.Name) and is_all_caps(t.id):
+                    name = t.id
+                    symbols.append({"name": name, "kind": "const", "line": node.lineno,
+                        "end_line": getattr(node, "end_lineno", None),
+                        "exported": is_exported(name), "signature": get_sig(node.lineno), "decorators": []})
+        elif isinstance(node, ast.AnnAssign):
+            if isinstance(node.target, ast.Name):
+                name = node.target.id
+                if has_final(node.annotation) or is_all_caps(name):
+                    symbols.append({"name": name, "kind": "const", "line": node.lineno,
+                        "end_line": getattr(node, "end_lineno", None),
+                        "exported": is_exported(name), "signature": get_sig(node.lineno), "decorators": []})
+    sys.stdout.write(json.dumps({"symbols": symbols}))
+
+main()
+`;
+var EXTRACT_IMPORTS_PY = `
+import sys, ast, json
+
+def main():
+    source = sys.stdin.read()
+    file_path = sys.argv[1] if len(sys.argv) > 1 else "<unknown>"
+    try:
+        tree = ast.parse(source, filename=file_path)
+    except SyntaxError as e:
+        sys.stdout.write(json.dumps({"error": "SyntaxError", "message": str(e), "lineno": e.lineno or 0}))
+        return
+    except Exception as e:
+        sys.stdout.write(json.dumps({"error": "ParseError", "message": str(e)}))
+        return
+
+    imports = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                entry = {"form": "import-module-alias" if alias.asname else "import-module",
+                    "module": alias.name, "names": [], "level": 0, "line": node.lineno}
+                if alias.asname: entry["alias"] = alias.asname
+                imports.append(entry)
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ""
+            level = node.level or 0
+            names = [a.name for a in node.names]
+            single_alias = node.names[0].asname if len(node.names) == 1 and node.names[0].asname else None
+            entry = {"form": "relative-from-import" if level > 0 else "from-import",
+                "module": module, "names": names, "level": level, "line": node.lineno}
+            if single_alias: entry["alias"] = single_alias
+            imports.append(entry)
+    imports.sort(key=lambda x: x["line"])
+    sys.stdout.write(json.dumps({"imports": imports}))
+
+main()
+`;
+var EXTRACT_CALLS_PY = `
+import sys, ast, json
+
+def main():
+    source = sys.stdin.read()
+    file_path = sys.argv[1] if len(sys.argv) > 1 else "<unknown>"
+    try:
+        tree = ast.parse(source, filename=file_path)
+    except SyntaxError as e:
+        sys.stdout.write(json.dumps({"error": "SyntaxError", "message": str(e), "lineno": e.lineno or 0}))
+        return
+    except Exception as e:
+        sys.stdout.write(json.dumps({"error": "ParseError", "message": str(e)}))
+        return
+
+    imports = []
+    definitions = []
+
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            definitions.append({"name": node.name, "file": file_path, "line": node.lineno, "kind": "function"})
+        elif isinstance(node, ast.ClassDef):
+            definitions.append({"name": node.name, "file": file_path, "line": node.lineno, "kind": "class"})
+            for child in node.body:
+                if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    definitions.append({"name": node.name + "." + child.name, "file": file_path, "line": child.lineno, "kind": "method"})
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append({"form": "import", "module": alias.name, "name": alias.asname or alias.name.split(".")[0]})
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ""
+            for alias in node.names:
+                imports.append({"form": "from", "module": module, "level": node.level or 0, "imported": alias.name, "name": alias.asname or alias.name})
+
+    def callee_name(expr, class_name):
+        if isinstance(expr, ast.Name):
+            return expr.id
+        if isinstance(expr, ast.Attribute):
+            parts = []
+            cur = expr
+            while isinstance(cur, ast.Attribute):
+                parts.append(cur.attr)
+                cur = cur.value
+            if isinstance(cur, ast.Name):
+                if cur.id == "self" and class_name:
+                    parts.append(class_name)
+                else:
+                    parts.append(cur.id)
+                return ".".join(reversed(parts))
+        return None
+
+    edges = []
+
+    class Visitor(ast.NodeVisitor):
+        def __init__(self):
+            self.class_name = None
+            self.caller = None
+
+        def visit_ClassDef(self, node):
+            old_class = self.class_name
+            self.class_name = node.name
+            for child in node.body:
+                self.visit(child)
+            self.class_name = old_class
+
+        def visit_FunctionDef(self, node):
+            self._visit_function(node)
+
+        def visit_AsyncFunctionDef(self, node):
+            self._visit_function(node)
+
+        def _visit_function(self, node):
+            old_caller = self.caller
+            name = self.class_name + "." + node.name if self.class_name else node.name
+            self.caller = {"file": file_path, "name": name, "line": node.lineno}
+            for child in node.body:
+                self.visit(child)
+            self.caller = old_caller
+
+        def visit_Call(self, node):
+            if self.caller:
+                name = callee_name(node.func, self.class_name)
+                if name:
+                    edges.append({"caller": self.caller, "calleeName": name, "callLine": node.lineno})
+            self.generic_visit(node)
+
+    Visitor().visit(tree)
+    sys.stdout.write(json.dumps({"definitions": definitions, "imports": imports, "edges": edges}))
+
+main()
+`;
+var PYTHON_TIMEOUT_MS = 15e3;
+function findPythonCmd() {
+  for (const cmd of ["python", "python3"]) {
+    const probe = spawnSync(cmd, ["--version"], { encoding: "utf8", shell: false, timeout: 5e3 });
+    if (!probe.error && probe.status === 0) return cmd;
+  }
+  return null;
+}
+var _pythonCmd = void 0;
+function getPythonCmd() {
+  if (_pythonCmd === void 0) _pythonCmd = findPythonCmd();
+  return _pythonCmd;
+}
+function runPythonScript(script, filePath, sourceText) {
+  const cmd = getPythonCmd();
+  if (!cmd) {
+    return { stdout: "", stderr: "", error: "Python interpreter not found on PATH (tried python, python3)." };
+  }
+  const result = spawnSync(cmd, ["-c", script, filePath], {
+    input: sourceText,
+    encoding: "utf8",
+    shell: false,
+    timeout: PYTHON_TIMEOUT_MS
+  });
+  if (result.error) {
+    const e = result.error;
+    return { stdout: "", stderr: "", error: `Python subprocess error: ${e.message}` };
+  }
+  if (result.status === null) {
+    return { stdout: "", stderr: "", error: `Python subprocess timed out after ${PYTHON_TIMEOUT_MS}ms` };
+  }
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: null
+  };
+}
+function parseJsonOutput(raw, filePath, context) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return { data: null, warning: `python-extraction: no output for ${context} from ${filePath}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return { data: null, warning: `python-extraction: could not parse ${context} output for ${filePath}` };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { data: null, warning: `python-extraction: unexpected ${context} output shape for ${filePath}` };
+  }
+  const obj = parsed;
+  if ("error" in obj) {
+    const msg = typeof obj["message"] === "string" ? obj["message"] : String(obj["error"]);
+    return { data: null, warning: `python-extraction: ${msg} in ${filePath}` };
+  }
+  return { data: obj, warning: null };
+}
+function mapPythonKind(kind) {
+  if (kind === "function") return "function";
+  if (kind === "class") return "class";
+  if (kind === "const") return "const";
+  return "variable";
+}
+function buildImportSpecifier(imp) {
+  if (imp.level > 0) {
+    const dots = ".".repeat(imp.level);
+    const mod = imp.module ? `${dots}${imp.module}` : dots;
+    return imp.names.length > 0 ? `from ${mod} import ${imp.names.join(", ")}` : mod;
+  }
+  if (imp.form === "import-module" || imp.form === "import-module-alias") {
+    return imp.module;
+  }
+  return imp.module;
+}
+function dedup2(arr) {
+  return [...new Set(arr)];
+}
+function buildModulePathMap(knownFiles) {
+  const map = /* @__PURE__ */ new Map();
+  for (const f of knownFiles) {
+    const norm = f.replace(/\\/g, "/");
+    const withoutExt = norm.endsWith(".py") ? norm.slice(0, -3) : norm.endsWith("/__init__.py") ? norm.slice(0, -12) : null;
+    if (withoutExt) {
+      const parts = withoutExt.split("/");
+      for (let start = parts.length - 1; start >= 0; start--) {
+        const key = parts.slice(start).join(".");
+        if (!map.has(key)) map.set(key, norm);
+      }
+    }
+  }
+  return map;
+}
+function resolveAbsoluteImport(module, knownSet, modulePathMap) {
+  if (!module) return null;
+  const direct = modulePathMap.get(module);
+  if (direct) return direct;
+  const asPath = module.replace(/\./g, "/");
+  for (const candidate of [asPath + ".py", asPath + "/__init__.py"]) {
+    if (knownSet.has(candidate)) return candidate;
+    for (const f of knownSet) {
+      if (f.endsWith("/" + candidate) || f === candidate) return f;
+    }
+  }
+  return null;
+}
+function resolveRelativeImport(imp, importingFile, knownSet) {
+  const norm = importingFile.replace(/\\/g, "/");
+  const dir = path5.posix.dirname(norm);
+  const parts = dir.split("/").filter((p) => p.length > 0);
+  const upCount = imp.level - 1;
+  if (upCount > parts.length) return null;
+  const baseParts = upCount > 0 ? parts.slice(0, parts.length - upCount) : parts;
+  const baseDir = baseParts.length > 0 ? baseParts.join("/") : ".";
+  if (!imp.module) {
+    if (imp.names.length === 0 || imp.names[0] === "*") return null;
+    const name = imp.names[0];
+    for (const c of [baseDir + "/" + name + ".py", baseDir + "/" + name + "/__init__.py"]) {
+      if (knownSet.has(c)) return c;
+    }
+    return null;
+  }
+  const moduleParts = imp.module.split(".");
+  const modulePath = moduleParts.join("/");
+  for (const c of [baseDir + "/" + modulePath + ".py", baseDir + "/" + modulePath + "/__init__.py"]) {
+    if (knownSet.has(c)) return c;
+  }
+  return null;
+}
+function specifierToPythonImport(specifier) {
+  const relMatch = specifier.match(/^from (\.+)([^\s]*)\s+import/);
+  if (relMatch) {
+    const level = relMatch[1].length;
+    const module = relMatch[2];
+    return { form: "relative-from-import", module, names: [], level, line: 0 };
+  }
+  const dotMatch = specifier.match(/^(\.+)(.*)$/);
+  if (dotMatch) {
+    return { form: "relative-from-import", module: dotMatch[2], names: [], level: dotMatch[1].length, line: 0 };
+  }
+  return { form: "from-import", module: specifier, names: [], level: 0, line: 0 };
+}
+function resolvePythonImportToFile(imp, importingFile, knownFiles) {
+  const knownSet = new Set(knownFiles);
+  const modulePathMap = buildModulePathMap(knownFiles);
+  if (imp.level > 0) {
+    return resolveRelativeImport(imp, importingFile, knownSet);
+  }
+  return resolveAbsoluteImport(imp.module, knownSet, modulePathMap);
+}
+var PythonAdapter = class {
+  extensions = [".py"];
+  supportsCallGraph = true;
+  extractFromSource(filePath, sourceText) {
+    const lineCount = sourceText.split("\n").length;
+    const warnings = [];
+    const symbols = [];
+    const imports = [];
+    const exports = [];
+    const symResult = runPythonScript(EXTRACT_SYMBOLS_PY, filePath, sourceText);
+    if (symResult.error) {
+      warnings.push(`python-extraction: ${symResult.error}`);
+    } else {
+      const parsed = parseJsonOutput(symResult.stdout, filePath, "symbols");
+      if (parsed.warning) {
+        warnings.push(parsed.warning);
+      } else if (parsed.data) {
+        const rawSymbols = Array.isArray(parsed.data["symbols"]) ? parsed.data["symbols"] : [];
+        for (const s of rawSymbols) {
+          if (!s.name || !s.kind) continue;
+          if (s.exported) exports.push(s.name);
+          symbols.push({
+            name: s.name,
+            kind: mapPythonKind(s.kind),
+            location: { file: filePath, line: s.line },
+            exported: s.exported,
+            signature: s.signature
+          });
+        }
+      }
+    }
+    const impResult = runPythonScript(EXTRACT_IMPORTS_PY, filePath, sourceText);
+    if (impResult.error) {
+      warnings.push(`python-extraction: ${impResult.error}`);
+    } else {
+      const parsed = parseJsonOutput(impResult.stdout, filePath, "imports");
+      if (parsed.warning) {
+        warnings.push(parsed.warning);
+      } else if (parsed.data) {
+        const rawImports = Array.isArray(parsed.data["imports"]) ? parsed.data["imports"] : [];
+        for (const imp of rawImports) {
+          const spec = buildImportSpecifier(imp);
+          if (spec) imports.push(spec);
+        }
+      }
+    }
+    return {
+      language: "python",
+      lineCount,
+      imports: dedup2(imports),
+      exports: dedup2(exports),
+      symbols,
+      reExportSpecifiers: [],
+      exportAllSpecifiers: []
+    };
+  }
+  resolveImportToFile(specifier, importingFile, knownFiles) {
+    const imp = specifierToPythonImport(specifier);
+    return resolvePythonImportToFile(imp, importingFile, knownFiles);
+  }
+  extractCallGraphEdges(files) {
+    const extractions = /* @__PURE__ */ new Map();
+    const definitionsByName = /* @__PURE__ */ new Map();
+    const knownFiles = files.map((f) => f.filePath);
+    for (const file of files) {
+      const result = runPythonScript(EXTRACT_CALLS_PY, file.filePath, file.sourceText);
+      if (result.error) continue;
+      const parsed = parseJsonOutput(result.stdout, file.filePath, "calls");
+      if (!parsed.data || parsed.warning) continue;
+      const extraction = {
+        definitions: Array.isArray(parsed.data["definitions"]) ? parsed.data["definitions"] : [],
+        imports: Array.isArray(parsed.data["imports"]) ? parsed.data["imports"] : [],
+        edges: Array.isArray(parsed.data["edges"]) ? parsed.data["edges"] : []
+      };
+      extractions.set(file.filePath, extraction);
+      for (const definition of extraction.definitions) {
+        if (!definitionsByName.has(definition.name)) {
+          definitionsByName.set(definition.name, definition);
+        }
+        const shortName = definition.kind === "method" ? null : definition.name.split(".").at(-1);
+        if (shortName && !definitionsByName.has(shortName)) {
+          definitionsByName.set(shortName, definition);
+        }
+      }
+    }
+    const edges = [];
+    for (const [filePath, extraction] of extractions) {
+      const importMap = buildPythonCallImportMap(extraction.imports, filePath, knownFiles);
+      for (const rawEdge of extraction.edges) {
+        edges.push({
+          caller: rawEdge.caller,
+          callee: {
+            file: resolvePythonCalleeFile(rawEdge.calleeName, importMap, definitionsByName),
+            name: rawEdge.calleeName
+          },
+          callLine: rawEdge.callLine
+        });
+      }
+    }
+    return dedupCallEdges(edges);
+  }
+};
+function buildPythonCallImportMap(imports, importingFile, knownFiles) {
+  const map = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    if (imp.form === "import") {
+      const file2 = resolvePythonImportToFile(
+        { form: "import-module", module: imp.module, names: [], level: 0, line: 0 },
+        importingFile,
+        knownFiles
+      );
+      map.set(imp.name, file2);
+      continue;
+    }
+    const file = resolvePythonImportToFile(
+      {
+        form: (imp.level ?? 0) > 0 ? "relative-from-import" : "from-import",
+        module: imp.module,
+        names: imp.imported ? [imp.imported] : [],
+        level: imp.level ?? 0,
+        line: 0
+      },
+      importingFile,
+      knownFiles
+    );
+    map.set(imp.name, file);
+  }
+  return map;
+}
+function resolvePythonCalleeFile(calleeName, importMap, definitionsByName) {
+  const directDefinition = definitionsByName.get(calleeName);
+  if (directDefinition) return directDefinition.file;
+  const parts = calleeName.split(".");
+  const base = parts[0];
+  if (importMap.has(base)) return importMap.get(base) ?? null;
+  if (parts.length === 1) {
+    const short = parts[0];
+    const shortDefinition = definitionsByName.get(short);
+    if (shortDefinition) return shortDefinition.file;
+  }
+  return null;
+}
+function dedupCallEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  return edges.filter((edge) => {
+    const key = [
+      edge.caller.file,
+      edge.caller.name,
+      edge.caller.line,
+      edge.callee.file ?? "",
+      edge.callee.name,
+      edge.callLine
+    ].join("\0");
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/languages/registry.ts
+var LanguageRegistry = class {
+  adapters = [];
+  register(adapter) {
+    this.adapters.push(adapter);
+  }
+  adapterForFile(filePath) {
+    const ext = path6.extname(filePath).toLowerCase();
+    for (const adapter of this.adapters) {
+      if (adapter.extensions.includes(ext)) return adapter;
+    }
+    return null;
+  }
+  supportsFile(filename) {
+    return this.adapterForFile(filename) !== null;
+  }
+};
+function createDefaultRegistry() {
+  const registry = new LanguageRegistry();
+  registry.register(new TypeScriptAdapter());
+  registry.register(new PythonAdapter());
+  return registry;
+}
+
+// src/indexing/discoverSourceFiles.ts
+import * as fs from "fs";
+import * as path7 from "path";
+var DEFAULT_IGNORED_DIRECTORY_NAMES = [
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  "playwright-report",
+  "test-results",
+  "output",
+  "out",
+  ".cache",
+  ".turbo",
+  ".vercel",
+  ".git",
+  ".pytest_cache",
+  "__pycache__",
+  ".venv",
+  "venv"
+];
+var DEFAULT_FILE_EXCLUDE_PATTERNS = [".d.ts", ".test.", ".spec."];
+var SAMPLE_LIMIT = 20;
+var LARGEST_FILE_LIMIT = 10;
+function discoverSourceFiles(options) {
+  const registry = options.registry ?? createDefaultRegistry();
+  const state = {
+    repoRoot: options.repoRoot,
+    registry,
+    defaultIgnoredDirectoryNames: new Set(DEFAULT_IGNORED_DIRECTORY_NAMES.map((name) => name.toLowerCase())),
+    userExcludeRules: normalizeExcludeRules(options.userExcludes ?? []),
+    userExcludes: (options.userExcludes ?? []).map(normalizePathInput),
+    startTime: Date.now(),
+    lastProgressTime: 0,
+    onProgress: options.onProgress,
+    result: {
+      files: [],
+      defaultIgnoredDirectoryNames: [...DEFAULT_IGNORED_DIRECTORY_NAMES],
+      userExcludes: (options.userExcludes ?? []).map(normalizePathInput),
+      totalFilesDiscovered: 0,
+      totalFilesEligibleForIndexing: 0,
+      totalFilesSkipped: 0,
+      skippedByDefaultIgnore: 0,
+      skippedByUserExclude: 0,
+      skippedByFilePattern: 0,
+      skippedUnsupportedFiles: 0,
+      languageCounts: {},
+      largestFiles: [],
+      sampleIndexedFiles: [],
+      sampleSkippedFiles: []
+    }
+  };
+  emitProgress(state, "scan-start", "Scanning source roots");
+  for (const root of options.sourceRoots) {
+    emitProgress(state, "scan-source-root", `Scanning ${root}`, root);
+    collectFiles(path7.resolve(options.repoRoot, root), state, root);
+  }
+  emitProgress(state, "scan-complete", "Source scan completed");
+  state.result.largestFiles.sort((a, b) => b.sizeBytes - a.sizeBytes);
+  return state.result;
+}
+function collectFiles(dir, state, currentSourceRoot) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const absPath = path7.join(dir, entry.name);
+    const relPath = toForwardSlash(path7.relative(state.repoRoot, absPath));
+    if (entry.isDirectory()) {
+      const userExclude2 = matchesUserExclude(relPath, entry.name, state.userExcludeRules);
+      if (userExclude2) {
+        recordSkipped(state, relPath, "user-exclude");
+        continue;
+      }
+      if (state.defaultIgnoredDirectoryNames.has(entry.name.toLowerCase())) {
+        recordSkipped(state, relPath, "default-ignore");
+        continue;
+      }
+      collectFiles(absPath, state, currentSourceRoot);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const userExclude = matchesUserExclude(relPath, entry.name, state.userExcludeRules);
+    if (userExclude) {
+      recordSkipped(state, relPath, "user-exclude");
+      continue;
+    }
+    state.result.totalFilesDiscovered += 1;
+    let stat;
+    try {
+      stat = fs.statSync(absPath);
+    } catch {
+      continue;
+    }
+    if (shouldExcludeByFilePattern(relPath)) {
+      recordSkipped(state, relPath, "file-pattern");
+      continue;
+    }
+    if (!state.registry.supportsFile(entry.name)) {
+      recordSkipped(state, relPath, "unsupported");
+      continue;
+    }
+    state.result.files.push({ relPath, absPath, sizeBytes: stat.size });
+    state.result.totalFilesEligibleForIndexing += 1;
+    incrementLanguageCount(state.result.languageCounts, relPath);
+    pushSample(state.result.sampleIndexedFiles, relPath);
+    trackLargestFile(state.result.largestFiles, { path: relPath, sizeBytes: stat.size });
+    maybeEmitProgress(state, currentSourceRoot);
+  }
+}
+function recordSkipped(state, relPath, reason) {
+  state.result.totalFilesSkipped += 1;
+  if (reason === "default-ignore") state.result.skippedByDefaultIgnore += 1;
+  if (reason === "user-exclude") state.result.skippedByUserExclude += 1;
+  if (reason === "file-pattern") state.result.skippedByFilePattern += 1;
+  if (reason === "unsupported") state.result.skippedUnsupportedFiles += 1;
+  pushSample(state.result.sampleSkippedFiles, { path: relPath, reason });
+}
+function shouldExcludeByFilePattern(relPath) {
+  return DEFAULT_FILE_EXCLUDE_PATTERNS.some((pattern) => relPath.includes(pattern));
+}
+function normalizeExcludeRules(values) {
+  return values.map(normalizePathInput).filter((value) => value.length > 0).map((value) => ({
+    normalized: value,
+    isPath: value.includes("/")
+  }));
+}
+function normalizePathInput(value) {
+  return toForwardSlash(value.trim()).replace(/^\/+|\/+$/g, "");
+}
+function matchesUserExclude(relPath, basename2, rules) {
+  const normalizedRelPath = normalizePathInput(relPath);
+  const segments = normalizedRelPath.split("/");
+  return rules.some((rule) => {
+    if (rule.isPath) {
+      return normalizedRelPath === rule.normalized || normalizedRelPath.startsWith(`${rule.normalized}/`);
+    }
+    return basename2 === rule.normalized || segments.includes(rule.normalized);
+  });
+}
+function incrementLanguageCount(languageCounts, relPath) {
+  const ext = path7.extname(relPath).toLowerCase();
+  const language = ext === ".py" ? "python" : ext === ".ts" || ext === ".tsx" ? "typescript" : ext === ".js" || ext === ".jsx" ? "javascript" : "unknown";
+  languageCounts[language] = (languageCounts[language] ?? 0) + 1;
+}
+function pushSample(samples, sample) {
+  if (samples.length < SAMPLE_LIMIT) samples.push(sample);
+}
+function trackLargestFile(samples, sample) {
+  samples.push(sample);
+  samples.sort((a, b) => b.sizeBytes - a.sizeBytes);
+  if (samples.length > LARGEST_FILE_LIMIT) samples.pop();
+}
+function maybeEmitProgress(state, currentSourceRoot) {
+  const now = Date.now();
+  if (now - state.lastProgressTime < 1e3) return;
+  state.lastProgressTime = now;
+  emitProgress(state, "scan-progress", "Scanning source files", currentSourceRoot);
+}
+function emitProgress(state, phase, message, currentSourceRoot) {
+  if (!state.onProgress) return;
+  state.onProgress({
+    phase,
+    message,
+    currentSourceRoot,
+    elapsedMs: Date.now() - state.startTime,
+    filesDiscovered: state.result.totalFilesDiscovered,
+    filesEligible: state.result.totalFilesEligibleForIndexing,
+    filesSkipped: state.result.totalFilesSkipped
+  });
+}
+
+// src/symbol-index/builder.ts
+function buildIndex(config) {
+  const startTime = Date.now();
+  const buildTime = (/* @__PURE__ */ new Date()).toISOString();
+  const registry = createDefaultRegistry();
+  const discovery = discoverSourceFiles({
+    repoRoot: config.repoRoot,
+    sourceRoots: config.sourceRoots,
+    userExcludes: config.excludePatterns,
+    registry,
+    onProgress: config.onProgress
+  });
+  const sourceFiles = discovery.files;
+  const callGraphInputsByAdapter = /* @__PURE__ */ new Map();
+  const summaries = [];
+  const rawExtractions = [];
+  emitBuildProgress(config, "index-start", "Indexing started", startTime, 0, sourceFiles.length);
+  let filesIndexed = 0;
+  let lastProgressTime = 0;
+  for (const { relPath, absPath } of sourceFiles) {
+    let sourceText;
+    try {
+      sourceText = fs2.readFileSync(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const adapter = registry.adapterForFile(relPath);
+    const result = adapter.extractFromSource(relPath, sourceText);
+    rawExtractions.push({ relPath, extraction: result });
+    summaries.push({
+      path: relPath,
+      language: result.language,
+      lineCount: result.lineCount,
+      imports: result.imports,
+      exports: result.exports,
+      symbols: result.symbols,
+      hasCallGraphEntries: false
+      // updated below if call graph is built
+    });
+    if (config.buildCallGraph && adapter.supportsCallGraph && adapter.extractCallGraphEdges) {
+      const inputs = callGraphInputsByAdapter.get(adapter) ?? [];
+      inputs.push({ filePath: relPath, sourceText });
+      callGraphInputsByAdapter.set(adapter, inputs);
+    }
+    filesIndexed += 1;
+    const now = Date.now();
+    if (now - lastProgressTime >= 1e3) {
+      lastProgressTime = now;
+      emitBuildProgress(config, "index-progress", "Indexing source files", startTime, filesIndexed, sourceFiles.length);
+    }
+  }
+  emitBuildProgress(config, "index-complete", "Indexing completed", startTime, filesIndexed, sourceFiles.length);
+  let callGraph = null;
+  if (config.buildCallGraph && callGraphInputsByAdapter.size > 0) {
+    emitBuildProgress(config, "call-graph-start", "Call graph building started", startTime, filesIndexed, sourceFiles.length);
+    const edges = [];
+    for (const [adapter, inputs] of callGraphInputsByAdapter) {
+      edges.push(...adapter.extractCallGraphEdges(inputs));
+    }
+    callGraph = createCallGraph(edges);
+    const filesWithEdges = /* @__PURE__ */ new Set();
+    for (const edge of callGraph.edges) {
+      filesWithEdges.add(edge.caller.file);
+      if (edge.callee.file) filesWithEdges.add(edge.callee.file);
+    }
+    for (const summary of summaries) {
+      if (filesWithEdges.has(summary.path)) {
+        summary.hasCallGraphEntries = true;
+      }
+    }
+    emitBuildProgress(config, "call-graph-complete", "Call graph building completed", startTime, filesIndexed, sourceFiles.length);
+  }
+  const indexedFileSet = new Set(summaries.map((s) => s.path));
+  const graph = buildGraphSection(rawExtractions, indexedFileSet, registry);
+  const symbolCount = summaries.reduce((n, f) => n + f.symbols.length, 0);
+  const index = {
+    schemaVersion: SCHEMA_VERSION,
+    buildTime,
+    repoRoot: config.repoRoot,
+    sourceRoots: config.sourceRoots,
+    fileCount: summaries.length,
+    symbolCount,
+    files: summaries,
+    graph
+    // callGraphArtifact set by writer after writing the artifact
+  };
+  return { index, callGraph, discovery };
+}
+function buildGraphSection(rawExtractions, indexedFileSet, registry) {
+  const fileDeps = [];
+  const symbols = [];
+  const knownFiles = [...indexedFileSet];
+  for (const { relPath, extraction } of rawExtractions) {
+    const adapter = registry.adapterForFile(relPath);
+    for (const specifier of extraction.imports) {
+      const to = adapter.resolveImportToFile(specifier, relPath, knownFiles);
+      if (to && to !== relPath) fileDeps.push({ from: relPath, to, kind: "import" });
+    }
+    for (const specifier of extraction.reExportSpecifiers) {
+      const to = adapter.resolveImportToFile(specifier, relPath, knownFiles);
+      if (to && to !== relPath) fileDeps.push({ from: relPath, to, kind: "re-export" });
+    }
+    for (const specifier of extraction.exportAllSpecifiers) {
+      const to = adapter.resolveImportToFile(specifier, relPath, knownFiles);
+      if (to && to !== relPath) fileDeps.push({ from: relPath, to, kind: "export-all" });
+    }
+    for (const sym of extraction.symbols) {
+      symbols.push({
+        file: relPath,
+        name: sym.name,
+        kind: sym.kind,
+        exported: sym.exported,
+        line: sym.location.line
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueDeps = fileDeps.filter((e) => {
+    const key = `${e.from}\0${e.to}\0${e.kind}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  uniqueDeps.sort(
+    (a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : a.to < b.to ? -1 : a.to > b.to ? 1 : 0
+  );
+  symbols.sort(
+    (a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : a.name < b.name ? -1 : a.name > b.name ? 1 : 0
+  );
+  return { fileDeps: uniqueDeps, symbols };
+}
+function emitBuildProgress(config, phase, message, startTime, filesIndexed, totalFiles) {
+  config.onProgress?.({
+    phase,
+    message,
+    elapsedMs: Date.now() - startTime,
+    filesIndexed,
+    totalFiles
+  });
+}
+
+// src/indexing/buildIndexManifest.ts
+function buildIndexManifest(options) {
+  return {
+    artifactKind: "my-dev-kit-v1-manifest",
+    version: "1.0.0",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot: options.projectRoot,
+    sourceRoots: options.sourceRoots,
+    languages: options.languages,
+    callGraphEnabled: options.callGraphEnabled,
+    artifacts: {
+      symbolIndex: "symbol-index.json",
+      codeGraph: "code-graph.json",
+      callGraph: options.callGraphProduced ? "call-graph.json" : null
+    },
+    summary: {
+      fileCount: options.symbolIndex.fileCount,
+      symbolCount: options.symbolIndex.symbolCount,
+      edgeCount: options.codeGraph.summary.edgeCount,
+      warningCount: options.warnings.length,
+      errorCount: options.errors.length
+    },
+    warnings: options.warnings,
+    errors: options.errors
+  };
+}
+
+// src/indexing/writeIndexManifest.ts
+import * as fs3 from "fs";
+import * as path8 from "path";
+function writeIndexArtifacts(options) {
+  fs3.mkdirSync(options.outputDir, { recursive: true });
+  writeJson(path8.join(options.outputDir, "manifest.json"), options.manifest);
+  writeJson(path8.join(options.outputDir, "symbol-index.json"), options.symbolIndex);
+  writeJson(path8.join(options.outputDir, "code-graph.json"), options.codeGraph);
+  if (options.callGraph) {
+    writeJson(path8.join(options.outputDir, "call-graph.json"), options.callGraph);
+  }
+}
+function writeJson(filePath, value) {
+  fs3.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+
+// src/indexing/runIndexCommand.ts
+var SUPPORTED_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "javascript", "python"]);
+async function runIndexCommand(options) {
+  const commandStartTime = Date.now();
+  const projectRoot = path9.resolve(options.root ?? ".");
+  const sourceRoots = options.src ?? [];
+  const warnings = [];
+  const errors = [];
+  if (sourceRoots.length === 0) {
+    throw new Error("The index command requires at least one --src <path> source root.");
+  }
+  if (options.language && !SUPPORTED_LANGUAGES.has(options.language)) {
+    throw new Error(`Unsupported language "${options.language}". Supported values: typescript, javascript, python.`);
+  }
+  const normalizedSourceRoots = sourceRoots.map((sourceRoot) => toForwardSlash(sourceRoot));
+  for (const sourceRoot of normalizedSourceRoots) {
+    const absoluteSourceRoot = path9.resolve(projectRoot, sourceRoot);
+    if (!fs4.existsSync(absoluteSourceRoot) || !fs4.statSync(absoluteSourceRoot).isDirectory()) {
+      throw new Error(`Source root does not exist or is not a directory: ${sourceRoot}`);
+    }
+  }
+  const outputDir = path9.resolve(projectRoot, options.out ?? ".my-dev-kit-v1");
+  const progress = createProgressReporter(options.progress === true, commandStartTime);
+  if (options.dryRun) {
+    const discovery = discoverSourceFiles({
+      repoRoot: projectRoot,
+      sourceRoots: normalizedSourceRoots,
+      userExcludes: options.exclude,
+      onProgress: progress
+    });
+    return buildDryRunResult(projectRoot, normalizedSourceRoots, outputDir, discovery);
+  }
+  const buildResult = buildIndex({
+    repoRoot: projectRoot,
+    sourceRoots: normalizedSourceRoots,
+    buildCallGraph: options.callGraph === true,
+    excludePatterns: options.exclude,
+    onProgress: progress
+  });
+  const languages = inferLanguages(buildResult.index.files.map((file) => file.language), options.language);
+  const codeGraph = buildCodeGraph({
+    symbolIndex: buildResult.index,
+    callGraph: buildResult.callGraph
+  });
+  const manifest = buildIndexManifest({
+    projectRoot: toForwardSlash(projectRoot),
+    sourceRoots: normalizedSourceRoots,
+    languages,
+    callGraphEnabled: options.callGraph === true,
+    callGraphProduced: buildResult.callGraph !== null,
+    symbolIndex: buildResult.index,
+    codeGraph,
+    warnings,
+    errors
+  });
+  progress?.({
+    phase: "artifact-write-start",
+    message: "Final artifact writing started",
+    elapsedMs: Date.now() - commandStartTime
+  });
+  writeIndexArtifacts({
+    outputDir,
+    manifest,
+    symbolIndex: buildResult.index,
+    codeGraph,
+    callGraph: buildResult.callGraph
+  });
+  progress?.({
+    phase: "artifact-write-complete",
+    message: "Final artifact writing completed",
+    elapsedMs: Date.now() - commandStartTime
+  });
+  return {
+    mode: "index",
+    manifest,
+    outputDir: toForwardSlash(outputDir),
+    symbolIndexPath: toForwardSlash(path9.join(outputDir, "symbol-index.json")),
+    codeGraphPath: toForwardSlash(path9.join(outputDir, "code-graph.json")),
+    callGraphPath: buildResult.callGraph ? toForwardSlash(path9.join(outputDir, "call-graph.json")) : null
+  };
+}
+function inferLanguages(languages, requestedLanguage) {
+  if (requestedLanguage) return [requestedLanguage];
+  return [...new Set(languages)].sort();
+}
+function buildDryRunResult(projectRoot, sourceRoots, outputDir, discovery) {
+  return {
+    mode: "dry-run",
+    projectRoot: toForwardSlash(projectRoot),
+    sourceRoots,
+    outputDir: toForwardSlash(outputDir),
+    defaultIgnoredDirectoryNames: discovery.defaultIgnoredDirectoryNames,
+    userExcludes: discovery.userExcludes,
+    totalFilesDiscovered: discovery.totalFilesDiscovered,
+    totalFilesEligibleForIndexing: discovery.totalFilesEligibleForIndexing,
+    totalFilesSkipped: discovery.totalFilesSkipped,
+    skippedByDefaultIgnore: discovery.skippedByDefaultIgnore,
+    skippedByUserExclude: discovery.skippedByUserExclude,
+    skippedByFilePattern: discovery.skippedByFilePattern,
+    skippedUnsupportedFiles: discovery.skippedUnsupportedFiles,
+    languageCounts: discovery.languageCounts,
+    largestFiles: discovery.largestFiles,
+    sampleIndexedFiles: discovery.sampleIndexedFiles,
+    sampleSkippedFiles: discovery.sampleSkippedFiles
+  };
+}
+function createProgressReporter(enabled, commandStartTime) {
+  if (!enabled) return void 0;
+  return (event) => {
+    const elapsedSeconds = ((event.elapsedMs || Date.now() - commandStartTime) / 1e3).toFixed(1);
+    const counts = "filesEligible" in event ? ` discovered=${event.filesDiscovered} eligible=${event.filesEligible} skipped=${event.filesSkipped}` : "filesIndexed" in event ? ` indexed=${event.filesIndexed}/${event.totalFiles}` : "";
+    const sourceRoot = "currentSourceRoot" in event && event.currentSourceRoot ? ` source=${event.currentSourceRoot}` : "";
+    process.stderr.write(`[my-dev-kit:index] ${event.message} (${elapsedSeconds}s)${sourceRoot}${counts}
+`);
+  };
+}
+
+// src/commands/indexCommand.ts
+function registerIndexCommand(program2) {
+  program2.command("index").description("Index a local TypeScript, JavaScript, or Python codebase.").option("--root <path>", "project root", ".").option("--src <path>", "source root to index; may be repeated", collectValues, []).option("--language <language>", "source language: typescript, javascript, or python").option("--out <dir>", "output directory", ".my-dev-kit-v1").option("--exclude <path-or-name>", "directory name or relative path prefix to exclude; may be repeated", collectValues, []).option("--dry-run", "scan and report what would be indexed without writing artifacts").option("--progress", "print bounded progress diagnostics to stderr").option("--call-graph", "include call graph when supported").option("--json", "print JSON output").action(async (options) => {
+    const result = await runIndexCommand(options);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.mode === "dry-run") {
+      printDryRunSummary(result);
+      return;
+    }
+    console.log(`Indexed ${result.manifest.summary.fileCount} file(s) and ${result.manifest.summary.symbolCount} symbol(s).`);
+    console.log(`Output: ${result.outputDir}`);
+    console.log("Artifacts: manifest.json, symbol-index.json, code-graph.json");
+    if (result.callGraphPath) {
+      console.log("Call graph: call-graph.json");
+    }
+  });
+}
+function collectValues(value, previous) {
+  return [...previous, value];
+}
+function printDryRunSummary(result) {
+  console.log("Dry-run scan completed.");
+  console.log(`Project root: ${result.projectRoot}`);
+  console.log(`Source roots: ${result.sourceRoots.join(", ")}`);
+  console.log(`Output directory: ${result.outputDir}`);
+  console.log(`Eligible files: ${result.totalFilesEligibleForIndexing}`);
+  console.log(`Files discovered: ${result.totalFilesDiscovered}`);
+  console.log(`Skipped paths: ${result.totalFilesSkipped}`);
+  console.log(`Skipped by default ignore: ${result.skippedByDefaultIgnore}`);
+  console.log(`Skipped by user exclude: ${result.skippedByUserExclude}`);
+  console.log(`Language counts: ${JSON.stringify(result.languageCounts)}`);
+  if (result.largestFiles.length > 0) {
+    console.log("Largest files:");
+    for (const file of result.largestFiles) {
+      console.log(`- ${file.path} (${file.sizeBytes} bytes)`);
+    }
+  }
+  if (result.sampleIndexedFiles.length > 0) {
+    console.log("Sample indexed files:");
+    for (const file of result.sampleIndexedFiles) console.log(`- ${file}`);
+  }
+  if (result.sampleSkippedFiles.length > 0) {
+    console.log("Sample skipped paths:");
+    for (const file of result.sampleSkippedFiles) console.log(`- ${file.path} (${file.reason})`);
+  }
+}
+
+// src/indexing/loadIndexArtifacts.ts
+import * as fs6 from "fs";
+
+// src/indexing/readIndexManifest.ts
+import * as fs5 from "fs";
+import * as path10 from "path";
+function readIndexManifest(indexDirInput) {
+  const indexDir = path10.resolve(indexDirInput);
+  const manifestPath = path10.join(indexDir, "manifest.json");
+  if (!fs5.existsSync(manifestPath)) {
+    throw new Error(`Missing index manifest: ${manifestPath}`);
+  }
+  const manifest = readJson(manifestPath);
+  validateManifest(manifest);
+  return {
+    indexDir,
+    manifestPath,
+    manifest,
+    artifactPaths: {
+      symbolIndex: resolveArtifactPath(indexDir, manifest.artifacts.symbolIndex, "symbolIndex"),
+      codeGraph: resolveArtifactPath(indexDir, manifest.artifacts.codeGraph, "codeGraph"),
+      callGraph: manifest.artifacts.callGraph ? resolveArtifactPath(indexDir, manifest.artifacts.callGraph, "callGraph") : null
+    }
+  };
+}
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs5.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in ${filePath}: ${error.message}`);
+    }
+    throw new Error(`Failed to read ${filePath}: ${error.message}`);
+  }
+}
+function validateManifest(value) {
+  if (!value || typeof value !== "object") throw new Error("Invalid manifest shape: expected an object.");
+  if (value.artifactKind !== "my-dev-kit-v1-manifest") {
+    throw new Error("Invalid manifest shape: artifactKind must be my-dev-kit-v1-manifest.");
+  }
+  if (!value.version) throw new Error("Invalid manifest shape: version is required.");
+  if (!value.projectRoot) throw new Error("Invalid manifest shape: projectRoot is required.");
+  if (!Array.isArray(value.sourceRoots)) throw new Error("Invalid manifest shape: sourceRoots must be an array.");
+  if (!value.artifacts || typeof value.artifacts !== "object") {
+    throw new Error("Invalid manifest shape: artifacts is required.");
+  }
+  if (!value.artifacts.symbolIndex) throw new Error("Invalid manifest shape: artifacts.symbolIndex is required.");
+  if (!value.artifacts.codeGraph) throw new Error("Invalid manifest shape: artifacts.codeGraph is required.");
+}
+function resolveArtifactPath(indexDir, artifactPath, name) {
+  if (!artifactPath) throw new Error(`Missing required artifact path: ${name}`);
+  const resolved = path10.resolve(indexDir, artifactPath);
+  if (!isInsideRoot(indexDir, resolved)) {
+    throw new Error(`Artifact path for "${name}" escapes the index directory: ${artifactPath}`);
+  }
+  return resolved;
+}
+
+// src/indexing/loadIndexArtifacts.ts
+function loadLookupArtifacts(indexDir) {
+  const resolved = readIndexManifest(indexDir);
+  return {
+    resolved,
+    codeGraph: readRequiredJson(resolved.artifactPaths.codeGraph, "code graph")
+  };
+}
+function loadSourceArtifacts(options) {
+  const resolved = readIndexManifest(options.indexDir);
+  return {
+    resolved,
+    codeGraph: options.loadCodeGraph ? readRequiredJson(resolved.artifactPaths.codeGraph, "code graph") : void 0,
+    symbolIndex: options.loadSymbolIndex ? readRequiredJson(resolved.artifactPaths.symbolIndex, "symbol index") : void 0
+  };
+}
+function readRequiredJson(filePath, label) {
+  if (!fs6.existsSync(filePath)) throw new Error(`Missing required ${label} artifact: ${filePath}`);
+  try {
+    return JSON.parse(fs6.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new Error(`Invalid JSON in ${filePath}: ${error.message}`);
+    throw new Error(`Failed to read ${filePath}: ${error.message}`);
+  }
+}
+
+// src/lookup/lookupNode.ts
+function lookupNode(options) {
+  validateDepth(options.depth);
+  const node = options.graph.nodes.find((candidate) => candidate.id === options.nodeId);
+  if (!node) throw new Error(`Node not found: ${options.nodeId}`);
+  const incomingEdges = options.graph.edges.filter((edge) => edge.target === options.nodeId).sort(compareById);
+  const outgoingEdges = options.graph.edges.filter((edge) => edge.source === options.nodeId).sort(compareById);
+  const neighbors = collectNeighbors(options.graph, options.nodeId, options.depth);
+  return {
+    status: "found",
+    indexDir: options.indexDir,
+    nodeId: options.nodeId,
+    depth: options.depth,
+    node,
+    incomingEdges,
+    outgoingEdges,
+    neighbors,
+    artifactPaths: {
+      manifest: options.manifestPath,
+      codeGraph: options.codeGraphPath
+    },
+    warnings: []
+  };
+}
+function validateDepth(depth) {
+  if (!Number.isInteger(depth)) throw new Error("Depth must be an integer.");
+  if (depth < 0) throw new Error("Depth must be 0 or greater.");
+  if (depth > 3) throw new Error("Depth greater than 3 is not supported.");
+}
+function collectNeighbors(graph, nodeId, depth) {
+  if (depth === 0) return [];
+  const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
+  const visited = /* @__PURE__ */ new Set([nodeId]);
+  const neighborIds = /* @__PURE__ */ new Set();
+  let frontier = /* @__PURE__ */ new Set([nodeId]);
+  for (let level = 0; level < depth; level++) {
+    const next = /* @__PURE__ */ new Set();
+    for (const current of frontier) {
+      for (const edge of graph.edges) {
+        const adjacent = edge.source === current ? edge.target : edge.target === current ? edge.source : null;
+        if (!adjacent || visited.has(adjacent)) continue;
+        visited.add(adjacent);
+        neighborIds.add(adjacent);
+        next.add(adjacent);
+      }
+    }
+    frontier = next;
+  }
+  return [...neighborIds].map((id) => nodesById.get(id)).filter((node) => node !== void 0).sort(compareById);
+}
+function compareById(a, b) {
+  return a.id.localeCompare(b.id);
+}
+
+// src/commands/parseUtils.ts
+function parseInteger(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) throw new Error(`Expected an integer, got "${value}".`);
+  return parsed;
+}
+
+// src/commands/lookupCommand.ts
+function registerLookupCommand(program2) {
+  program2.command("lookup").description("Look up an indexed graph node.").option("--index <dir>", "index artifact directory", ".my-dev-kit-v1").option("--node <node-id>", "node id to look up").option("--depth <n>", "traversal depth", parseInteger, 1).option("--json", "print JSON output").action((options) => {
+    if (!options.node) throw new Error("The lookup command requires --node <node-id>.");
+    const artifacts = loadLookupArtifacts(options.index);
+    const result = lookupNode({
+      graph: artifacts.codeGraph,
+      indexDir: options.index,
+      nodeId: options.node,
+      depth: options.depth,
+      manifestPath: `${options.index}/manifest.json`,
+      codeGraphPath: `${options.index}/${artifacts.resolved.manifest.artifacts.codeGraph}`
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(`Found ${result.node.kind} node: ${result.node.id}`);
+    console.log(`Incoming edges: ${result.incomingEdges.length}`);
+    console.log(`Outgoing edges: ${result.outgoingEdges.length}`);
+    console.log(`Neighbors within depth ${result.depth}: ${result.neighbors.length}`);
+  });
+}
+
+// src/commands/searchCommand.ts
+import * as fs7 from "fs";
+
+// src/search/rankSearchResults.ts
+var ALL_TERMS_BONUS = 10;
+var EXACT_PHRASE_MULTIPLIER = 2;
+var MAX_MATCH_TEXT_LENGTH = 120;
+function normalizeSearchQuery(query) {
+  return query.trim().toLowerCase().split(/[\s.,;:()[\]{}<>"'`|\\/!?@#$%^&*+=~-]+/u).map((term) => term.trim()).filter(Boolean);
+}
+function rankSearchResults(options) {
+  const phrase = options.query.trim().toLowerCase();
+  const ranked = options.candidates.map((candidate) => scoreCandidate(candidate, phrase, options.normalizedTerms)).filter((item) => item !== null).sort(compareResults);
+  return ranked.slice(0, options.limit);
+}
+function scoreCandidate(candidate, phrase, terms) {
+  const reasons = [];
+  const matchedTerms = /* @__PURE__ */ new Set();
+  for (const field2 of candidate.fields) {
+    const normalizedText = field2.text.toLowerCase();
+    if (phrase && normalizedText.includes(phrase)) {
+      reasons.push({
+        field: field2.field,
+        term: phrase,
+        weight: field2.weight * EXACT_PHRASE_MULTIPLIER,
+        text: shorten(field2.text)
+      });
+    }
+    for (const term of terms) {
+      if (!normalizedText.includes(term)) continue;
+      matchedTerms.add(term);
+      reasons.push({
+        field: field2.field,
+        term,
+        weight: field2.weight,
+        text: shorten(field2.text)
+      });
+    }
+  }
+  if (reasons.length === 0) return null;
+  const dedupedReasons = dedupeReasons(reasons);
+  const baseScore = dedupedReasons.reduce((sum, reason) => sum + reason.weight, 0);
+  const score = baseScore + (terms.length > 0 && matchedTerms.size === terms.length ? ALL_TERMS_BONUS : 0);
+  return {
+    ...candidate.item,
+    score,
+    matchReasons: dedupedReasons.sort(compareReasons)
+  };
+}
+function dedupeReasons(reasons) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const reason of reasons) {
+    const key = `${reason.field}\0${reason.term}\0${reason.text}\0${reason.weight}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(reason);
+  }
+  return result;
+}
+function compareResults(a, b) {
+  return b.score - a.score || a.kind.localeCompare(b.kind) || stableResultKey(a).localeCompare(stableResultKey(b));
+}
+function stableResultKey(item) {
+  return item.path ?? item.id;
+}
+function compareReasons(a, b) {
+  return b.weight - a.weight || a.field.localeCompare(b.field) || a.term.localeCompare(b.term) || a.text.localeCompare(b.text);
+}
+function shorten(text) {
+  const compact = text.replace(/\s+/g, " ").trim();
+  if (compact.length <= MAX_MATCH_TEXT_LENGTH) return compact;
+  return `${compact.slice(0, MAX_MATCH_TEXT_LENGTH - 3)}...`;
+}
+
+// src/search/searchIndex.ts
+var DEFAULT_LIMIT = 20;
+var WEIGHTS = {
+  path: 8,
+  label: 6,
+  symbolName: 12,
+  symbolKind: 4,
+  import: 5,
+  export: 10,
+  edgeKind: 3,
+  nodeId: 4,
+  neighbor: 2
+};
+var EDGE_WEIGHTS = {
+  nodeId: 1,
+  neighbor: 1
+};
+function searchIndex(input) {
+  validateArtifacts(input.symbolIndex, input.codeGraph);
+  const normalizedTerms = normalizeSearchQuery(input.query);
+  if (normalizedTerms.length === 0) throw new Error("Search query must include at least one non-empty term.");
+  const limit = input.limit ?? DEFAULT_LIMIT;
+  const candidates = buildCandidates(input.symbolIndex, input.codeGraph);
+  const results = rankSearchResults({
+    candidates,
+    query: input.query,
+    normalizedTerms,
+    limit
+  });
+  const searchedFileIds = /* @__PURE__ */ new Set();
+  const searchedSymbolIds = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (candidate.item.kind === "file") searchedFileIds.add(candidate.item.id);
+    if (candidate.item.kind === "symbol") searchedSymbolIds.add(candidate.item.id);
+  }
+  return {
+    artifactKind: "my-dev-kit-v1-search-result",
+    version: "1.0.0",
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    indexDir: input.resolved.indexDir,
+    query: input.query,
+    normalizedTerms,
+    limit,
+    results,
+    summary: {
+      resultCount: results.length,
+      searchedFileCount: searchedFileIds.size,
+      searchedSymbolCount: searchedSymbolIds.size,
+      searchedEdgeCount: input.codeGraph.edges.length
+    },
+    artifactPaths: {
+      manifest: input.resolved.manifestPath,
+      symbolIndex: input.resolved.artifactPaths.symbolIndex,
+      codeGraph: input.resolved.artifactPaths.codeGraph
+    },
+    warnings: []
+  };
+}
+function buildCandidates(symbolIndex, codeGraph) {
+  const candidates = /* @__PURE__ */ new Map();
+  const nodesById = new Map(codeGraph.nodes.map((node) => [node.id, node]));
+  for (const node of codeGraph.nodes) {
+    mergeCandidate(candidates, nodeCandidate(node));
+  }
+  for (const file of symbolIndex.files) {
+    mergeCandidate(candidates, fileCandidate(file));
+    for (const symbol of file.symbols) {
+      mergeCandidate(candidates, symbolCandidate(file, symbol));
+    }
+  }
+  for (const dep of symbolIndex.graph?.fileDeps ?? []) {
+    mergeCandidate(candidates, {
+      item: {
+        kind: "file",
+        id: fileNodeId2(dep.from),
+        label: dep.from,
+        path: dep.from,
+        nodeId: fileNodeId2(dep.from)
+      },
+      fields: [
+        field("neighbor", dep.to, WEIGHTS.neighbor),
+        field("edgeKind", dep.kind, WEIGHTS.edgeKind)
+      ]
+    });
+  }
+  for (const edge of codeGraph.edges) {
+    mergeCandidate(candidates, edgeCandidate(edge, nodesById));
+  }
+  return [...candidates.values()].sort((a, b) => a.item.kind.localeCompare(b.item.kind) || a.item.id.localeCompare(b.item.id));
+}
+function nodeCandidate(node) {
+  const fields = [
+    field("nodeId", node.id, WEIGHTS.nodeId),
+    field("label", node.label, WEIGHTS.label)
+  ];
+  if (node.path) fields.push(field("path", node.path, WEIGHTS.path));
+  if (node.symbolName) fields.push(field("symbolName", node.symbolName, WEIGHTS.symbolName));
+  if (node.symbolKind) fields.push(field("symbolKind", node.symbolKind, WEIGHTS.symbolKind));
+  if (node.exported && node.symbolName) fields.push(field("export", node.symbolName, WEIGHTS.export));
+  return {
+    item: {
+      kind: node.kind,
+      id: node.id,
+      label: node.label,
+      path: node.path,
+      nodeId: node.id
+    },
+    fields
+  };
+}
+function fileCandidate(file) {
+  return {
+    item: {
+      kind: "file",
+      id: fileNodeId2(file.path),
+      label: file.path,
+      path: file.path,
+      nodeId: fileNodeId2(file.path)
+    },
+    fields: [
+      field("path", file.path, WEIGHTS.path),
+      ...file.imports.map((value) => field("import", value, WEIGHTS.import)),
+      ...file.exports.map((value) => field("export", value, WEIGHTS.export))
+    ]
+  };
+}
+function symbolCandidate(file, symbol) {
+  const fields = [
+    field("path", file.path, WEIGHTS.path),
+    field("symbolName", symbol.name, WEIGHTS.symbolName),
+    field("symbolKind", symbol.kind, WEIGHTS.symbolKind)
+  ];
+  if (symbol.exported) fields.push(field("export", symbol.name, WEIGHTS.export));
+  if (symbol.signature) fields.push(field("label", symbol.signature, WEIGHTS.label));
+  return {
+    item: {
+      kind: "symbol",
+      id: symbolNodeId2(file.path, symbol.name),
+      label: symbol.name,
+      path: file.path,
+      nodeId: symbolNodeId2(file.path, symbol.name)
+    },
+    fields
+  };
+}
+function edgeCandidate(edge, nodesById) {
+  const source = nodesById.get(edge.source);
+  const target = nodesById.get(edge.target);
+  const label = edge.label ?? edge.kind;
+  return {
+    item: {
+      kind: "edge",
+      id: edge.id,
+      label: `${edge.source} --${label}--> ${edge.target}`,
+      edge: {
+        source: edge.source,
+        target: edge.target,
+        kind: edge.kind
+      }
+    },
+    fields: [
+      field("edgeKind", edge.kind, WEIGHTS.edgeKind),
+      field("edgeKind", label, WEIGHTS.edgeKind),
+      field("nodeId", edge.id, EDGE_WEIGHTS.nodeId),
+      field("neighbor", edge.source, EDGE_WEIGHTS.neighbor),
+      field("neighbor", edge.target, EDGE_WEIGHTS.neighbor),
+      ...source?.path ? [field("neighbor", source.path, EDGE_WEIGHTS.neighbor)] : [],
+      ...target?.path ? [field("neighbor", target.path, EDGE_WEIGHTS.neighbor)] : [],
+      ...source?.label ? [field("neighbor", source.label, EDGE_WEIGHTS.neighbor)] : [],
+      ...target?.label ? [field("neighbor", target.label, EDGE_WEIGHTS.neighbor)] : []
+    ]
+  };
+}
+function mergeCandidate(candidates, candidate) {
+  const key = `${candidate.item.kind}:${candidate.item.id}`;
+  const existing = candidates.get(key);
+  if (!existing) {
+    candidates.set(key, candidate);
+    return;
+  }
+  existing.fields.push(...candidate.fields);
+  existing.item.label = existing.item.label || candidate.item.label;
+  existing.item.path = existing.item.path ?? candidate.item.path;
+  existing.item.nodeId = existing.item.nodeId ?? candidate.item.nodeId;
+  existing.item.edge = existing.item.edge ?? candidate.item.edge;
+}
+function field(fieldName, text, weight) {
+  return { field: fieldName, text, weight };
+}
+function validateArtifacts(symbolIndex, codeGraph) {
+  if (!symbolIndex || typeof symbolIndex !== "object" || !Array.isArray(symbolIndex.files)) {
+    throw new Error("Invalid symbol index artifact: files must be an array.");
+  }
+  if (!codeGraph || typeof codeGraph !== "object" || !Array.isArray(codeGraph.nodes) || !Array.isArray(codeGraph.edges)) {
+    throw new Error("Invalid code graph artifact: nodes and edges must be arrays.");
+  }
+}
+function fileNodeId2(filePath) {
+  return `file:${filePath}`;
+}
+function symbolNodeId2(filePath, name) {
+  return `symbol:${filePath}#${name}`;
+}
+
+// src/commands/searchCommand.ts
+var DEFAULT_LIMIT2 = 20;
+var MAX_LIMIT = 100;
+function registerSearchCommand(program2) {
+  program2.command("search").description("Search indexed files, symbols, and graph edges.").option("--index <dir>", "index artifact directory", ".my-dev-kit-v1").option("--query <text>", "search query").option("--limit <n>", `result limit, 1 through ${MAX_LIMIT}`, parseLimit, DEFAULT_LIMIT2).option("--json", "print JSON output").action((options) => {
+    if (!options.query) throw new Error("The search command requires --query <text>.");
+    const resolved = readIndexManifest(options.index);
+    const result = searchIndex({
+      resolved,
+      symbolIndex: readRequiredJson2(resolved.artifactPaths.symbolIndex, "symbol index"),
+      codeGraph: readRequiredJson2(resolved.artifactPaths.codeGraph, "code graph"),
+      query: options.query,
+      limit: options.limit
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printTextResult(result);
+  });
+}
+function parseLimit(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) throw new Error(`Expected --limit to be an integer, got "${value}".`);
+  if (parsed < 1) throw new Error("--limit must be a positive integer.");
+  if (parsed > MAX_LIMIT) throw new Error(`--limit must be ${MAX_LIMIT} or less.`);
+  return parsed;
+}
+function readRequiredJson2(filePath, label) {
+  if (!fs7.existsSync(filePath)) throw new Error(`Missing required ${label} artifact: ${filePath}`);
+  try {
+    return JSON.parse(fs7.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new Error(`Invalid JSON in ${filePath}: ${error.message}`);
+    throw new Error(`Failed to read ${filePath}: ${error.message}`);
+  }
+}
+function printTextResult(result) {
+  console.log(`Search query: ${result.query}`);
+  console.log(`Index dir: ${result.indexDir}`);
+  console.log(`Results: ${result.results.length}`);
+  for (const [index, item] of result.results.entries()) {
+    const target = item.path ? `${item.id} (${item.path})` : item.id;
+    console.log(`${index + 1}. [${item.kind}] score ${item.score}: ${item.label} - ${target}`);
+    const reasons = item.matchReasons.slice(0, 3).map((reason) => `${reason.field}:${reason.term}`).join(", ");
+    if (reasons) console.log(`   matches: ${reasons}`);
+  }
+}
+
+// src/graph/sliceGraph.ts
+function sliceGraph(options) {
+  validateSliceInputs(options.depth, options.direction);
+  const nodeMap = new Map(options.graph.nodes.map((node) => [node.id, node]));
+  if (!nodeMap.has(options.focusNodeId)) throw new Error(`Node not found: ${options.focusNodeId}`);
+  const includedNodeIds = /* @__PURE__ */ new Set([options.focusNodeId]);
+  let frontier = /* @__PURE__ */ new Set([options.focusNodeId]);
+  for (let level = 0; level < options.depth; level++) {
+    const next = /* @__PURE__ */ new Set();
+    for (const current of frontier) {
+      for (const edge of options.graph.edges) {
+        for (const adjacent of adjacentNodes(edge, current, options.direction)) {
+          if (includedNodeIds.has(adjacent)) continue;
+          includedNodeIds.add(adjacent);
+          next.add(adjacent);
+        }
+      }
+    }
+    frontier = next;
+  }
+  const nodes = [...includedNodeIds].map((id) => nodeMap.get(id)).filter((node) => node !== void 0).sort(compareById2);
+  const edges = dedupeEdges(options.graph.edges).filter((edge) => includedNodeIds.has(edge.source) && includedNodeIds.has(edge.target)).filter((edge) => edgeAllowedForDirection(edge, includedNodeIds, options.focusNodeId, options.direction)).sort(compareById2);
+  return { nodes, edges, warnings: [] };
+}
+function validateSliceInputs(depth, direction) {
+  if (!Number.isInteger(depth)) throw new Error("Depth must be an integer.");
+  if (depth < 0) throw new Error("Depth must be 0 or greater.");
+  if (depth > 3) throw new Error("Depth greater than 3 is not supported.");
+  if (!["both", "incoming", "outgoing"].includes(direction)) {
+    throw new Error("Direction must be one of: both, incoming, outgoing.");
+  }
+}
+function summarizeSlice(nodes, edges) {
+  return {
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    nodesByKind: countBy(nodes.map((node) => node.kind)),
+    edgesByKind: countBy(edges.map((edge) => edge.kind))
+  };
+}
+function adjacentNodes(edge, current, direction) {
+  if (direction === "outgoing") return edge.source === current ? [edge.target] : [];
+  if (direction === "incoming") return edge.target === current ? [edge.source] : [];
+  if (edge.source === current) return [edge.target];
+  if (edge.target === current) return [edge.source];
+  return [];
+}
+function edgeAllowedForDirection(edge, includedNodeIds, focusNodeId, direction) {
+  if (direction === "both") return true;
+  if (focusNodeId && includedNodeIds.size > 0) return true;
+  return edge.source !== edge.target;
+}
+function dedupeEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const edge of edges) {
+    if (seen.has(edge.id)) continue;
+    seen.add(edge.id);
+    result.push(edge);
+  }
+  return result;
+}
+function countBy(values) {
+  const counts = {};
+  for (const value of values.sort()) counts[value] = (counts[value] ?? 0) + 1;
+  return counts;
+}
+function compareById2(a, b) {
+  return a.id.localeCompare(b.id);
+}
+
+// src/graph/writeGraphSlice.ts
+import * as fs8 from "fs";
+import * as path11 from "path";
+function writeGraphSlice(outputPath, slice) {
+  const resolved = path11.resolve(outputPath);
+  fs8.mkdirSync(path11.dirname(resolved), { recursive: true });
+  fs8.writeFileSync(resolved, `${JSON.stringify(slice, null, 2)}
+`, "utf8");
+  return resolved.replace(/\\/g, "/");
+}
+
+// src/commands/sliceCommand.ts
+function registerSliceCommand(program2) {
+  program2.command("slice").description("Build a bounded graph neighborhood slice.").option("--index <dir>", "index artifact directory", ".my-dev-kit-v1").option("--node <node-id>", "node id to slice around").option("--depth <n>", "slice depth", parseInteger, 1).option("--direction <both|incoming|outgoing>", "traversal direction", "both").option("--out <path>", "output path").option("--json", "print JSON output").action((options) => {
+    if (!options.node) throw new Error("The slice command requires --node <node-id>.");
+    const artifacts = loadLookupArtifacts(options.index);
+    const core = sliceGraph({
+      graph: artifacts.codeGraph,
+      focusNodeId: options.node,
+      depth: options.depth,
+      direction: options.direction
+    });
+    const slice = {
+      artifactKind: "my-dev-kit-v1-graph-slice",
+      version: "1.0.0",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      indexDir: options.index,
+      focusNodeId: options.node,
+      depth: options.depth,
+      direction: options.direction,
+      nodes: core.nodes,
+      edges: core.edges,
+      summary: summarizeSlice(core.nodes, core.edges),
+      artifactPaths: {
+        manifest: `${options.index}/manifest.json`,
+        codeGraph: `${options.index}/${artifacts.resolved.manifest.artifacts.codeGraph}`
+      },
+      warnings: core.warnings
+    };
+    const writtenPath = options.out ? writeGraphSlice(options.out, slice) : null;
+    const result = { ...slice, outputPath: writtenPath };
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(`Graph slice: ${slice.summary.nodeCount} node(s), ${slice.summary.edgeCount} edge(s).`);
+    if (writtenPath) console.log(`Wrote: ${writtenPath}`);
+  });
+}
+
+// src/lookup/getSourceSlice.ts
+import * as fs9 from "fs";
+import * as path12 from "path";
+function ensureInsideProjectRoot(projectRoot, filePath) {
+  const root = path12.resolve(projectRoot);
+  const resolved = path12.resolve(root, filePath);
+  const relative4 = path12.relative(root, resolved);
+  if (relative4.startsWith("..") || path12.isAbsolute(relative4)) {
+    throw new Error(`File path escapes the indexed project root: ${filePath}`);
+  }
+  return resolved;
+}
+function getSourceSlice(options) {
+  validateLineRange(options.startLine, options.endLine, options.maxLines);
+  const absolutePath = ensureInsideProjectRoot(options.projectRoot, options.filePath);
+  if (!fs9.existsSync(absolutePath) || !fs9.statSync(absolutePath).isFile()) {
+    throw new Error(`Source file does not exist: ${options.filePath}`);
+  }
+  const lines = fs9.readFileSync(absolutePath, "utf8").split(/\r?\n/);
+  if (options.startLine > lines.length) {
+    throw new Error(`Start line ${options.startLine} is beyond the end of file ${options.filePath}.`);
+  }
+  const endLine = Math.min(options.endLine, lines.length);
+  const content = lines.slice(options.startLine - 1, endLine).join("\n");
+  return {
+    status: "ok",
+    mode: options.mode,
+    indexDir: options.indexDir,
+    filePath: toForwardSlash(options.filePath),
+    absolutePath: toForwardSlash(absolutePath),
+    symbolName: options.symbolName ?? null,
+    startLine: options.startLine,
+    endLine,
+    lineCount: endLine - options.startLine + 1,
+    content,
+    warnings: options.warnings ?? []
+  };
+}
+function validateLineRange(startLine, endLine, maxLines) {
+  if (!Number.isInteger(startLine) || !Number.isInteger(endLine)) {
+    throw new Error("Start and end lines must be positive integers.");
+  }
+  if (startLine < 1 || endLine < 1) throw new Error("Start and end lines must be positive integers.");
+  if (startLine > endLine) throw new Error("Start line must be less than or equal to end line.");
+  if (!Number.isInteger(maxLines) || maxLines < 1) throw new Error("Max lines must be a positive integer.");
+  const requested = endLine - startLine + 1;
+  if (requested > maxLines) {
+    throw new Error(`Requested source slice has ${requested} lines, which exceeds --max-lines ${maxLines}.`);
+  }
+}
+
+// src/lookup/resolveSourceTarget.ts
+function resolveFileNodeTarget(graph, nodeId, maxLines) {
+  const node = findNode(graph, nodeId);
+  if (node.kind === "file") {
+    if (!node.path) throw new Error(`File node does not include a source path: ${nodeId}`);
+    return {
+      mode: "node",
+      filePath: node.path,
+      startLine: 1,
+      endLine: maxLines,
+      warnings: ["File node retrieval returns a capped preview, not the whole file."]
+    };
+  }
+  if (node.kind === "symbol") {
+    const filePath = node.path ?? parseSymbolNodeId(node.id).filePath;
+    const symbolName = node.symbolName ?? parseSymbolNodeId(node.id).symbolName;
+    if (!filePath || !symbolName) throw new Error(`Symbol node does not include retrievable source metadata: ${nodeId}`);
+    return { mode: "symbol", filePath, symbolName, warnings: [] };
+  }
+  throw new Error("Node is not a source-retrievable file or symbol node.");
+}
+function resolveSymbolTarget(symbolIndex, filePath, symbolName, maxLines) {
+  const file = symbolIndex.files.find((candidate) => candidate.path === normalize2(filePath));
+  if (!file) throw new Error(`File is not present in the current symbol index: ${filePath}`);
+  const symbol = file.symbols.find((candidate) => candidate.name === symbolName);
+  if (!symbol) throw new Error(`Symbol not found in ${filePath}: ${symbolName}`);
+  if (!symbol.location || typeof symbol.location.line !== "number") {
+    throw new Error("Symbol was found, but source location is not available in the current symbol index.");
+  }
+  const endLine = Math.min(file.lineCount, symbol.location.line + Math.min(maxLines, 20) - 1);
+  return {
+    mode: "symbol",
+    filePath: file.path,
+    symbolName: symbol.name,
+    startLine: symbol.location.line,
+    endLine,
+    warnings: ["Symbol location has a start line only; returning a small bounded preview from that line."]
+  };
+}
+function findNode(graph, nodeId) {
+  const node = graph.nodes.find((candidate) => candidate.id === nodeId);
+  if (!node) throw new Error(`Node not found: ${nodeId}`);
+  return node;
+}
+function parseSymbolNodeId(nodeId) {
+  if (!nodeId.startsWith("symbol:")) return { filePath: null, symbolName: null };
+  const body = nodeId.slice("symbol:".length);
+  const marker = body.lastIndexOf("#");
+  if (marker < 0) return { filePath: null, symbolName: null };
+  return { filePath: body.slice(0, marker), symbolName: body.slice(marker + 1) };
+}
+function normalize2(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+
+// src/source/renderSourceOutput.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import * as path13 from "path";
+function parseSourceOutputFormat(value) {
+  if (value === "json" || value === "plain" || value === "numbered") return value;
+  throw new Error(`Unsupported --format value "${value}". Supported values: json, plain, numbered.`);
+}
+function renderSourceOutput(result, format) {
+  if (format === "json") return JSON.stringify(result, null, 2) + "\n";
+  if (format === "plain") return result.content.endsWith("\n") ? result.content : result.content + "\n";
+  return renderNumberedSource(result.content, result.startLine);
+}
+function renderNumberedSource(content, startLine) {
+  const lines = content.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const lastLine = startLine + lines.length - 1;
+  const width = String(lastLine).length;
+  const numbered = lines.map((line, i) => {
+    const num = String(startLine + i).padStart(width);
+    return `${num} | ${line}`;
+  });
+  return numbered.join("\n") + "\n";
+}
+function writeSourceOutput(outputPath, rendered) {
+  const resolved = path13.resolve(outputPath);
+  mkdirSync3(path13.dirname(resolved), { recursive: true });
+  writeFileSync3(resolved, rendered, "utf8");
+  return resolved;
+}
+
+// src/commands/sourceCommand.ts
+function registerSourceCommand(program2) {
+  program2.command("source").description("Retrieve bounded source from an indexed project.").option("--index <dir>", "index artifact directory", ".my-dev-kit-v1").option("--node <node-id>", "node id to retrieve source for").option("--file <path>", "file path").option("--start <n>", "start line", parseInteger).option("--end <n>", "end line", parseInteger).option("--symbol <name>", "symbol name").option("--max-lines <n>", "maximum returned lines", parseInteger, 160).option("--format <json|plain|numbered>", "output format").option("--out <path>", "write output to file").option("--json", "print JSON output (alias for --format json)").action((options) => {
+    const format = resolveFormat(options);
+    const mode = selectMode(options);
+    const artifacts = loadSourceArtifacts({
+      indexDir: options.index,
+      loadCodeGraph: mode === "node",
+      loadSymbolIndex: mode === "symbol" || mode === "node"
+    });
+    let target;
+    if (mode === "line-range") {
+      target = {
+        mode,
+        filePath: options.file,
+        startLine: options.start,
+        endLine: options.end,
+        warnings: []
+      };
+    } else if (mode === "symbol") {
+      target = resolveSymbolTarget(artifacts.symbolIndex, options.file, options.symbol, options.maxLines);
+    } else {
+      const nodeTarget = resolveFileNodeTarget(artifacts.codeGraph, options.node, options.maxLines);
+      target = nodeTarget.mode === "symbol" ? resolveSymbolTarget(artifacts.symbolIndex, nodeTarget.filePath, nodeTarget.symbolName, options.maxLines) : nodeTarget;
+    }
+    const result = getSourceSlice({
+      indexDir: options.index,
+      projectRoot: artifacts.resolved.manifest.projectRoot,
+      filePath: target.filePath,
+      startLine: target.startLine,
+      endLine: target.endLine,
+      maxLines: options.maxLines,
+      mode,
+      symbolName: target.symbolName,
+      warnings: target.warnings
+    });
+    if (format === void 0) {
+      if (options.out) {
+        const rendered2 = renderSourceOutput(result, "plain");
+        const writtenPath = writeSourceOutput(options.out, rendered2);
+        console.log(`Wrote plain source to ${writtenPath}`);
+      } else {
+        console.log(`${result.filePath}:${result.startLine}-${result.endLine}`);
+        if (result.warnings.length > 0) console.log(`Warnings: ${result.warnings.join("; ")}`);
+        console.log(result.content);
+      }
+      return;
+    }
+    const rendered = renderSourceOutput(result, format);
+    if (options.out) {
+      const writtenPath = writeSourceOutput(options.out, rendered);
+      if (format === "json") {
+        console.log(`Wrote JSON source result to ${writtenPath}`);
+      } else {
+        console.log(`Wrote ${format} source to ${writtenPath}`);
+      }
+      return;
+    }
+    process.stdout.write(rendered);
+  });
+}
+function resolveFormat(options) {
+  if (options.json && options.format !== void 0 && options.format !== "json") {
+    throw new Error(`--json and --format ${options.format} cannot be used together. Use --format json or omit --json.`);
+  }
+  if (options.json) return "json";
+  if (options.format !== void 0) return parseSourceOutputFormat(options.format);
+  return void 0;
+}
+function selectMode(options) {
+  const hasNode = options.node !== void 0;
+  const hasRange = options.file !== void 0 || options.start !== void 0 || options.end !== void 0;
+  const hasSymbol = options.symbol !== void 0;
+  if (hasNode && (hasRange || hasSymbol)) throw new Error("Use only one source mode: --node, --file with --start/--end, or --file with --symbol.");
+  if (!hasNode && !hasRange && !hasSymbol) throw new Error("Provide one source mode: --node, --file with --start/--end, or --file with --symbol.");
+  if (hasNode) return "node";
+  if (hasSymbol) {
+    if (!options.file) throw new Error("Symbol mode requires --file <path> and --symbol <name>.");
+    if (options.start !== void 0 || options.end !== void 0) throw new Error("Do not mix --symbol with --start/--end.");
+    return "symbol";
+  }
+  if (!options.file) throw new Error("Line range mode requires --file <path>.");
+  if (options.start === void 0) throw new Error("--start is required when --end is provided.");
+  if (options.end === void 0) throw new Error("--end is required when --start is provided.");
+  return "line-range";
+}
+
+// src/commands/viewCommand.ts
+import * as path15 from "path";
+
+// src/graph/edgeStyleConvention.ts
+var KNOWN_EDGE_KINDS = [
+  "defines",
+  "imports",
+  "exports",
+  "calls",
+  "depends-on",
+  "related-to"
+];
+var EDGE_ATTR_MAP = {
+  defines: { dir: "both", arrowtail: "dot", arrowhead: "normal", style: "solid" },
+  imports: { dir: "both", arrowtail: "dot", arrowhead: "inv", style: "solid" },
+  exports: { dir: "both", arrowtail: "dot", arrowhead: "onormal", style: "solid" },
+  calls: { dir: "both", arrowtail: "dot", arrowhead: "normal", style: "bold" },
+  "depends-on": { dir: "both", arrowtail: "dot", arrowhead: "inv", style: "dashed" },
+  "related-to": { dir: "both", arrowtail: "odot", arrowhead: "odot", style: "dotted" }
+};
+var FALLBACK_ATTRS = { dir: "forward", arrowtail: "none", arrowhead: "normal", style: "solid" };
+function getEdgeAttrs(kind) {
+  return EDGE_ATTR_MAP[kind] ?? FALLBACK_ATTRS;
+}
+function formatEdgeAttrs(attrs) {
+  return `dir="${attrs.dir}", arrowtail="${attrs.arrowtail}", arrowhead="${attrs.arrowhead}", style="${attrs.style}"`;
+}
+function buildLegendLines() {
+  const lines = [
+    "  subgraph cluster_legend {",
+    '    label="Edge Legend"; style=dotted; color=gray;'
+  ];
+  for (const kind of KNOWN_EDGE_KINDS) {
+    const src = `legend_${kind.replace("-", "_")}_src`;
+    const tgt = `legend_${kind.replace("-", "_")}_tgt`;
+    const attrs = getEdgeAttrs(kind);
+    lines.push(`    "${src}" [label="${kind} (source)", shape=plaintext, fontsize=9];`);
+    lines.push(`    "${tgt}" [label="${kind} (target)", shape=plaintext, fontsize=9];`);
+    lines.push(`    "${src}" -> "${tgt}" [${formatEdgeAttrs(attrs)}, label="${kind}", fontsize=9];`);
+  }
+  lines.push("  }");
+  return lines;
+}
+
+// src/graph/buildDotGraph.ts
+function buildDotGraph(graph, options = {}) {
+  const mode = options.edgeStyle ?? "semantic";
+  const lines = ["digraph CodeGraph {", "  rankdir=LR;"];
+  for (const node of [...graph.nodes].sort(compareById3)) {
+    lines.push(`  ${quote(node.id)} [label=${quote(nodeLabel(node))}, shape=${quote(nodeShape(node))}];`);
+  }
+  for (const edge of [...graph.edges].sort(compareById3)) {
+    if (mode === "labeled") {
+      lines.push(`  ${quote(edge.source)} -> ${quote(edge.target)} [label=${quote(edge.label ?? edge.kind)}];`);
+    } else if (mode === "minimal") {
+      lines.push(`  ${quote(edge.source)} -> ${quote(edge.target)};`);
+    } else {
+      const attrs = getEdgeAttrs(edge.kind);
+      lines.push(`  ${quote(edge.source)} -> ${quote(edge.target)} [${formatEdgeAttrs(attrs)}];`);
+    }
+  }
+  if (mode === "semantic") {
+    lines.push(...buildLegendLines());
+  }
+  lines.push("}");
+  return `${lines.join("\n")}
+`;
+}
+function nodeLabel(node) {
+  if (node.kind === "file") return node.path ?? node.label;
+  if (node.kind === "symbol") return node.symbolName ?? node.label;
+  return node.label;
+}
+function nodeShape(node) {
+  if (node.kind === "file") return "box";
+  if (node.kind === "symbol") return "ellipse";
+  return "oval";
+}
+function quote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, "\\n")}"`;
+}
+function compareById3(a, b) {
+  return a.id.localeCompare(b.id);
+}
+
+// src/graph/renderGraphviz.ts
+import { spawnSync as spawnSync2 } from "child_process";
+function isGraphvizAvailable() {
+  const result = spawnSync2("dot", ["-V"], { encoding: "utf8", shell: false });
+  return result.status === 0;
+}
+function renderGraphviz(dotText, format) {
+  const result = spawnSync2("dot", [`-T${format}`], {
+    input: dotText,
+    encoding: format === "svg" ? "utf8" : "buffer",
+    shell: false,
+    maxBuffer: 20 * 1024 * 1024
+  });
+  if (result.error) throw new Error(`Graphviz dot failed: ${result.error.message}`);
+  if (result.status !== 0) {
+    const stderr = typeof result.stderr === "string" ? result.stderr : result.stderr?.toString("utf8");
+    throw new Error(`Graphviz dot failed with exit code ${result.status}: ${stderr ?? ""}`.trim());
+  }
+  return Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.from(result.stdout, "utf8");
+}
+
+// src/graph/writeGraphView.ts
+import * as fs10 from "fs";
+import * as path14 from "path";
+function writeGraphView(outputPath, content) {
+  const resolved = path14.resolve(outputPath);
+  fs10.mkdirSync(path14.dirname(resolved), { recursive: true });
+  fs10.writeFileSync(resolved, content);
+  return resolved.replace(/\\/g, "/");
+}
+
+// src/commands/viewCommand.ts
+function registerViewCommand(program2) {
+  program2.command("view").description("Render code graph artifacts as DOT, SVG, or PNG.").option("--index <dir>", "index artifact directory", ".my-dev-kit-v1").option("--format <dot|svg|png>", "output format", "dot").option("--out <path>", "output path").option("--edge-style <semantic|labeled|minimal>", "edge visualization style", "semantic").option("--allow-dot-fallback", "fall back when Graphviz dot is unavailable").option("--json", "print JSON output").action((options) => {
+    const requestedFormat = parseFormat(options.format);
+    const edgeStyle = parseEdgeStyle(options.edgeStyle);
+    const artifacts = loadLookupArtifacts(options.index);
+    const dotText = buildDotGraph(artifacts.codeGraph, { edgeStyle });
+    const warnings = [];
+    let actualFormat = requestedFormat;
+    let graphvizUsed = false;
+    let dotFallbackUsed = false;
+    let outputPath = options.out ?? path15.join(options.index, `graph.${requestedFormat}`);
+    let content = dotText;
+    if (requestedFormat !== "dot") {
+      if (!isGraphvizAvailable()) {
+        if (!options.allowDotFallback) {
+          throw new Error("Graphviz dot executable is not available. Install Graphviz or use --allow-dot-fallback.");
+        }
+        warnings.push("Graphviz dot executable is not available; wrote DOT fallback instead.");
+        actualFormat = "dot";
+        dotFallbackUsed = true;
+        outputPath = options.out ?? path15.join(options.index, "graph.dot");
+        if (!outputPath.endsWith(".dot")) outputPath = outputPath.replace(/\.(svg|png)$/i, ".dot");
+      } else {
+        content = renderGraphviz(dotText, requestedFormat);
+        graphvizUsed = true;
+      }
+    }
+    const writtenPath = writeGraphView(outputPath, content);
+    const result = {
+      status: "ok",
+      indexDir: options.index,
+      requestedFormat,
+      actualFormat,
+      outputPath: writtenPath,
+      nodeCount: artifacts.codeGraph.nodes.length,
+      edgeCount: artifacts.codeGraph.edges.length,
+      graphvizUsed,
+      dotFallbackUsed,
+      edgeStyle,
+      warnings
+    };
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(`Wrote ${actualFormat.toUpperCase()} graph: ${writtenPath}`);
+    if (warnings.length > 0) console.log(`Warnings: ${warnings.join("; ")}`);
+  });
+}
+function parseFormat(format) {
+  if (format === "dot" || format === "svg" || format === "png") return format;
+  throw new Error(`Unsupported view format "${format}". Supported values: dot, svg, png.`);
+}
+function parseEdgeStyle(value) {
+  if (value === "semantic" || value === "labeled" || value === "minimal") return value;
+  throw new Error(`Unsupported --edge-style value "${value}". Supported values: semantic, labeled, minimal.`);
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/cli.ts
+function createProgram() {
+  const program2 = new Command();
+  program2.name("my-dev-kit").description("Local codebase graph, indexing, slicing, source retrieval, search, and Graphviz visualization CLI.").version(VERSION);
+  registerIndexCommand(program2);
+  registerViewCommand(program2);
+  registerLookupCommand(program2);
+  registerSourceCommand(program2);
+  registerSliceCommand(program2);
+  registerSearchCommand(program2);
+  return program2;
+}
+var program = createProgram();
+program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exitCode = 2;
+});
+export {
+  createProgram
+};