@swarmvaultai/engine 0.1.14 → 0.1.16

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-MZSUYTSL.js";
+} from "./chunk-EEWB4WGH.js";
 
 // src/agents.ts
 import fs from "fs/promises";
@@ -30,10 +30,10 @@ var managedStart = "<!-- swarmvault:managed:start -->";
 var managedEnd = "<!-- swarmvault:managed:end -->";
 var legacyManagedStart = "<!-- vault:managed:start -->";
 var legacyManagedEnd = "<!-- vault:managed:end -->";
-function buildManagedBlock(agent) {
+function buildManagedBlock(target) {
   const body = [
     managedStart,
-    `# SwarmVault Rules (${agent})`,
+    "# SwarmVault Rules",
     "",
     "- Read `swarmvault.schema.md` before compile or query style work. It is the canonical schema path.",
     "- Treat `raw/` as immutable source input.",
@@ -45,11 +45,27 @@ function buildManagedBlock(agent) {
     managedEnd,
     ""
   ].join("\n");
-  if (agent === "cursor") {
+  if (target === "cursor") {
     return body;
   }
   return body;
 }
+function targetPathForAgent(rootDir, agent) {
+  switch (agent) {
+    case "codex":
+    case "goose":
+    case "pi":
+      return path.join(rootDir, "AGENTS.md");
+    case "claude":
+      return path.join(rootDir, "CLAUDE.md");
+    case "gemini":
+      return path.join(rootDir, "GEMINI.md");
+    case "cursor":
+      return path.join(rootDir, ".cursor", "rules", "swarmvault.mdc");
+    default:
+      throw new Error(`Unsupported agent ${String(agent)}`);
+  }
+}
 async function upsertManagedBlock(filePath, block) {
   const existing = await fileExists(filePath) ? await fs.readFile(filePath, "utf8") : "";
   if (!existing) {
@@ -72,23 +88,25 @@ ${block}
 }
 async function installAgent(rootDir, agent) {
   await initWorkspace(rootDir);
-  const block = buildManagedBlock(agent);
+  const target = targetPathForAgent(rootDir, agent);
   switch (agent) {
-    case "codex": {
-      const target = path.join(rootDir, "AGENTS.md");
-      await upsertManagedBlock(target, block);
+    case "codex":
+    case "goose":
+    case "pi":
+      await upsertManagedBlock(target, buildManagedBlock("agents"));
       return target;
-    }
     case "claude": {
-      const target = path.join(rootDir, "CLAUDE.md");
-      await upsertManagedBlock(target, block);
+      await upsertManagedBlock(target, buildManagedBlock("claude"));
+      return target;
+    }
+    case "gemini": {
+      await upsertManagedBlock(target, buildManagedBlock("gemini"));
       return target;
     }
     case "cursor": {
-      const rulesDir = path.join(rootDir, ".cursor", "rules");
+      const rulesDir = path.dirname(target);
       await ensureDir(rulesDir);
-      const target = path.join(rulesDir, "swarmvault.mdc");
-      await fs.writeFile(target, `${block}
+      await fs.writeFile(target, `${buildManagedBlock("cursor")}
 `, "utf8");
       return target;
     }
@@ -98,7 +116,14 @@ async function installAgent(rootDir, agent) {
 }
 async function installConfiguredAgents(rootDir) {
   const { config } = await initWorkspace(rootDir);
-  return Promise.all(config.agents.map((agent) => installAgent(rootDir, agent)));
+  const dedupedTargets = /* @__PURE__ */ new Map();
+  for (const agent of config.agents) {
+    const target = targetPathForAgent(rootDir, agent);
+    if (!dedupedTargets.has(target)) {
+      dedupedTargets.set(target, agent);
+    }
+  }
+  return Promise.all([...dedupedTargets.values()].map((agent) => installAgent(rootDir, agent)));
 }
 
 // src/ingest.ts
@@ -125,7 +150,7 @@ function scriptKindFor(language) {
   }
 }
 function isRelativeSpecifier(specifier) {
-  return specifier.startsWith("./") || specifier.startsWith("../");
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith(".");
 }
 function formatDiagnosticCategory(category) {
   switch (category) {
@@ -177,6 +202,22 @@ function collectCallNames(root, availableNames, selfName) {
   visit(root);
   return uniqueBy(names, (name) => name);
 }
+function collectCallNamesFromText(text, availableNames, selfName) {
+  if (!text) {
+    return [];
+  }
+  const names = [];
+  for (const name of availableNames) {
+    if (name === selfName) {
+      continue;
+    }
+    const pattern = new RegExp(`\\b${escapeRegExp(name)}\\s*\\(`, "g");
+    if (pattern.test(text)) {
+      names.push(name);
+    }
+  }
+  return uniqueBy(names, (name) => name);
+}
 function heritageNames(clauses, token) {
   return uniqueBy(
     (clauses ?? []).filter((clause) => clause.token === token).flatMap(
@@ -277,7 +318,689 @@ function codeQuestions(manifest, code) {
 function resolveVariableKind(statement) {
   return statement.declarationList.flags & ts.NodeFlags.Const ? "variable" : "variable";
 }
-function analyzeTopLevelCode(manifest, content) {
+function splitLines(content) {
+  return content.split(/\r?\n/);
+}
+function leadingIndent(line) {
+  const match = line.match(/^[ \t]*/);
+  return match ? match[0].replace(/\t/g, "    ").length : 0;
+}
+function normalizeSymbolReference(value) {
+  const withoutGenerics = value.replace(/<[^>]*>/g, "");
+  const withoutDecorators = withoutGenerics.replace(/['"&*()[\]{}]/g, " ");
+  const trimmed = withoutDecorators.trim();
+  const lastSegment = trimmed.split(/::|\./).filter(Boolean).at(-1) ?? trimmed;
+  return lastSegment.replace(/[,:;]+$/g, "").trim();
+}
+function singleLineSignature(line) {
+  return truncate(
+    normalizeWhitespace(
+      line.replace(/\{\s*$/, "").replace(/:\s*$/, ":").trim()
+    ),
+    180
+  );
+}
+function buildDiagnostic(code, message, line, column = 1, category = "warning") {
+  return { code, category, message, line, column };
+}
+function finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics) {
+  const topLevelNames = new Set(draftSymbols.map((symbol) => symbol.name));
+  for (const symbol of draftSymbols) {
+    if (symbol.callNames.length === 0 && symbol.bodyText) {
+      symbol.callNames = collectCallNamesFromText(symbol.bodyText, topLevelNames, symbol.name);
+    }
+  }
+  const seenSymbolIds = /* @__PURE__ */ new Map();
+  const symbols = draftSymbols.map((symbol) => ({
+    id: makeSymbolId(manifest.sourceId, symbol.name, seenSymbolIds),
+    name: symbol.name,
+    kind: symbol.kind,
+    signature: symbol.signature,
+    exported: symbol.exported,
+    calls: uniqueBy(symbol.callNames, (name) => name),
+    extends: uniqueBy(symbol.extendsNames.map((name) => normalizeSymbolReference(name)).filter(Boolean), (name) => name),
+    implements: uniqueBy(symbol.implementsNames.map((name) => normalizeSymbolReference(name)).filter(Boolean), (name) => name)
+  }));
+  return {
+    moduleId: `module:${manifest.sourceId}`,
+    language,
+    imports,
+    dependencies: uniqueBy(
+      imports.filter((item) => item.isExternal).map((item) => item.specifier),
+      (specifier) => specifier
+    ),
+    symbols,
+    exports: uniqueBy([...symbols.filter((symbol) => symbol.exported).map((symbol) => symbol.name), ...exportLabels], (label) => label),
+    diagnostics
+  };
+}
+function collectPythonBlock(lines, startIndex) {
+  const startIndent = leadingIndent(lines[startIndex] ?? "");
+  const parts = [];
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const trimmed = line.trim();
+    if (!trimmed) {
+      parts.push(line);
+      continue;
+    }
+    if (leadingIndent(line) <= startIndent) {
+      break;
+    }
+    parts.push(line);
+  }
+  return parts.join("\n");
+}
+function parsePythonImportList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean).map((item) => {
+    const [rawSpecifier, rawAlias] = item.split(/\s+as\s+/i);
+    return {
+      specifier: rawSpecifier.trim(),
+      alias: rawAlias?.trim()
+    };
+  });
+}
+function parsePythonAllExportList(value) {
+  const match = value.match(/\[(.*)\]/);
+  if (!match) {
+    return [];
+  }
+  return uniqueBy(
+    match[1].split(",").map((item) => item.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean),
+    (item) => item
+  );
+}
+function analyzePythonCode(manifest, content) {
+  const lines = splitLines(content);
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const diagnostics = [];
+  let explicitExports = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index] ?? "";
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("#") || leadingIndent(rawLine) > 0) {
+      continue;
+    }
+    const importMatch = trimmed.match(/^import\s+(.+)$/);
+    if (importMatch) {
+      for (const item of parsePythonImportList(importMatch[1])) {
+        imports.push({
+          specifier: item.specifier,
+          importedSymbols: [],
+          namespaceImport: item.alias,
+          isExternal: !isRelativeSpecifier(item.specifier),
+          reExport: false
+        });
+      }
+      continue;
+    }
+    const fromImportMatch = trimmed.match(/^from\s+([.\w]+)\s+import\s+(.+)$/);
+    if (fromImportMatch) {
+      const importedSymbols = fromImportMatch[2].split(",").map((item) => item.trim()).filter(Boolean);
+      imports.push({
+        specifier: fromImportMatch[1],
+        importedSymbols,
+        isExternal: !isRelativeSpecifier(fromImportMatch[1]),
+        reExport: false
+      });
+      continue;
+    }
+    const classMatch = trimmed.match(/^class\s+([A-Za-z_]\w*)\s*(?:\(([^)]*)\))?\s*:/);
+    if (classMatch) {
+      const baseNames = classMatch[2] ? classMatch[2].split(",").map((item) => normalizeSymbolReference(item)).filter(Boolean) : [];
+      draftSymbols.push({
+        name: classMatch[1],
+        kind: "class",
+        signature: singleLineSignature(trimmed),
+        exported: !classMatch[1].startsWith("_"),
+        callNames: [],
+        extendsNames: baseNames,
+        implementsNames: [],
+        bodyText: collectPythonBlock(lines, index)
+      });
+      continue;
+    }
+    if (trimmed.startsWith("class ")) {
+      diagnostics.push(buildDiagnostic(1001, "Python class declaration is missing a trailing colon.", index + 1));
+      continue;
+    }
+    const functionMatch = trimmed.match(/^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/);
+    if (functionMatch) {
+      draftSymbols.push({
+        name: functionMatch[1],
+        kind: "function",
+        signature: singleLineSignature(trimmed),
+        exported: !functionMatch[1].startsWith("_"),
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: collectPythonBlock(lines, index)
+      });
+      continue;
+    }
+    if (trimmed.startsWith("def ") || trimmed.startsWith("async def ")) {
+      diagnostics.push(buildDiagnostic(1002, "Python function declaration is missing a trailing colon.", index + 1));
+      continue;
+    }
+    const allMatch = trimmed.match(/^__all__\s*=\s*\[(.*)\]\s*$/);
+    if (allMatch) {
+      explicitExports = parsePythonAllExportList(trimmed);
+      continue;
+    }
+    const variableMatch = trimmed.match(/^([A-Za-z_]\w*)\s*(?::[^=]+)?=\s*(.+)$/);
+    if (variableMatch && !["True", "False", "None"].includes(variableMatch[1])) {
+      draftSymbols.push({
+        name: variableMatch[1],
+        kind: "variable",
+        signature: singleLineSignature(trimmed),
+        exported: !variableMatch[1].startsWith("_"),
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: variableMatch[2]
+      });
+    }
+  }
+  if (explicitExports.length > 0) {
+    const explicitExportSet = new Set(explicitExports);
+    for (const symbol of draftSymbols) {
+      symbol.exported = explicitExportSet.has(symbol.name);
+    }
+    exportLabels.push(...explicitExports);
+  }
+  return finalizeCodeAnalysis(manifest, "python", imports, draftSymbols, exportLabels, diagnostics);
+}
+function collectBracedBlock(lines, startIndex) {
+  const parts = [];
+  let depth = 0;
+  let started = false;
+  for (let index = startIndex; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    parts.push(line);
+    for (const character of line) {
+      if (character === "{") {
+        depth += 1;
+        started = true;
+      } else if (character === "}") {
+        depth -= 1;
+      }
+    }
+    if (started && depth <= 0) {
+      return { text: parts.join("\n"), endIndex: index };
+    }
+  }
+  return {
+    text: parts.join("\n"),
+    endIndex: started ? lines.length - 1 : startIndex
+  };
+}
+function exportedByCapitalization(name) {
+  return /^[A-Z]/.test(name);
+}
+function parseGoImportLine(line) {
+  const match = line.trim().match(/^(?:([._A-Za-z]\w*)\s+)?"([^"]+)"$/);
+  if (!match) {
+    return void 0;
+  }
+  return {
+    specifier: match[2],
+    importedSymbols: [],
+    namespaceImport: match[1] && ![".", "_"].includes(match[1]) ? match[1] : void 0,
+    isExternal: !isRelativeSpecifier(match[2]),
+    reExport: false
+  };
+}
+function receiverTypeName(receiver) {
+  const tokens = receiver.replace(/[()*]/g, " ").split(/\s+/).map((item) => item.trim()).filter(Boolean);
+  return normalizeSymbolReference(tokens.at(-1) ?? "");
+}
+function analyzeGoCode(manifest, content) {
+  const lines = splitLines(content);
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const diagnostics = [];
+  let inImportBlock = false;
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index] ?? "";
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("//")) {
+      continue;
+    }
+    if (inImportBlock) {
+      if (trimmed === ")") {
+        inImportBlock = false;
+        continue;
+      }
+      const parsed = parseGoImportLine(trimmed);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    const importBlockMatch = trimmed.match(/^import\s+\($/);
+    if (importBlockMatch) {
+      inImportBlock = true;
+      continue;
+    }
+    const singleImportMatch = trimmed.match(/^import\s+(.+)$/);
+    if (singleImportMatch) {
+      const parsed = parseGoImportLine(singleImportMatch[1]);
+      if (parsed) {
+        imports.push(parsed);
+      }
+      continue;
+    }
+    const typeMatch = trimmed.match(/^type\s+([A-Za-z_]\w*)\s+(struct|interface)\b/);
+    if (typeMatch) {
+      const exported = exportedByCapitalization(typeMatch[1]);
+      draftSymbols.push({
+        name: typeMatch[1],
+        kind: typeMatch[2] === "interface" ? "interface" : "class",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: collectBracedBlock(lines, index).text
+      });
+      if (exported) {
+        exportLabels.push(typeMatch[1]);
+      }
+      continue;
+    }
+    const aliasTypeMatch = trimmed.match(/^type\s+([A-Za-z_]\w*)\b(?!\s+(?:struct|interface)\b)/);
+    if (aliasTypeMatch) {
+      const exported = exportedByCapitalization(aliasTypeMatch[1]);
+      draftSymbols.push({
+        name: aliasTypeMatch[1],
+        kind: "type_alias",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: trimmed
+      });
+      if (exported) {
+        exportLabels.push(aliasTypeMatch[1]);
+      }
+      continue;
+    }
+    const funcMatch = trimmed.match(/^func\s+(?:\(([^)]*)\)\s*)?([A-Za-z_]\w*)\s*\(/);
+    if (funcMatch) {
+      const receiverType = funcMatch[1] ? receiverTypeName(funcMatch[1]) : "";
+      const symbolName = receiverType ? `${receiverType}.${funcMatch[2]}` : funcMatch[2];
+      const exported = exportedByCapitalization(funcMatch[2]);
+      const block = collectBracedBlock(lines, index);
+      draftSymbols.push({
+        name: symbolName,
+        kind: "function",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: block.text
+      });
+      if (exported) {
+        exportLabels.push(symbolName);
+      }
+      index = block.endIndex;
+      continue;
+    }
+    const variableMatch = trimmed.match(/^(?:var|const)\s+([A-Za-z_]\w*)\b/);
+    if (variableMatch) {
+      const exported = exportedByCapitalization(variableMatch[1]);
+      draftSymbols.push({
+        name: variableMatch[1],
+        kind: "variable",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: trimmed
+      });
+      if (exported) {
+        exportLabels.push(variableMatch[1]);
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "go", imports, draftSymbols, exportLabels, diagnostics);
+}
+function analyzeRustUseStatement(statement) {
+  const cleaned = statement.replace(/^pub\s+/, "").replace(/^use\s+/, "").replace(/;$/, "").trim();
+  const aliasMatch = cleaned.match(/\s+as\s+([A-Za-z_]\w*)$/);
+  const withoutAlias = aliasMatch ? cleaned.slice(0, aliasMatch.index).trim() : cleaned;
+  const braceMatch = withoutAlias.match(/^(.*)::\{(.+)\}$/);
+  const importedSymbols = braceMatch ? braceMatch[2].split(",").map((item) => item.trim()).filter(Boolean) : [aliasMatch ? `${normalizeSymbolReference(withoutAlias)} as ${aliasMatch[1]}` : normalizeSymbolReference(withoutAlias)].filter(
+    Boolean
+  );
+  const specifier = braceMatch ? braceMatch[1].trim() : withoutAlias;
+  return {
+    specifier,
+    importedSymbols,
+    isExternal: !/^(crate|self|super)::/.test(specifier),
+    reExport: statement.trim().startsWith("pub use ")
+  };
+}
+function rustVisibilityPrefix(trimmed) {
+  return /^(pub(?:\([^)]*\))?\s+)/.test(trimmed);
+}
+function analyzeRustCode(manifest, content) {
+  const lines = splitLines(content);
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const diagnostics = [];
+  const symbolByName = /* @__PURE__ */ new Map();
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index] ?? "";
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("//")) {
+      continue;
+    }
+    const useMatch = trimmed.match(/^(?:pub\s+)?use\s+.+;$/);
+    if (useMatch) {
+      imports.push(analyzeRustUseStatement(trimmed));
+      continue;
+    }
+    const functionMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?fn\s+([A-Za-z_]\w*)\s*\(/);
+    if (functionMatch) {
+      const exported = rustVisibilityPrefix(trimmed);
+      const block = collectBracedBlock(lines, index);
+      const symbol = {
+        name: functionMatch[1],
+        kind: "function",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: block.text
+      };
+      draftSymbols.push(symbol);
+      symbolByName.set(symbol.name, symbol);
+      if (exported) {
+        exportLabels.push(symbol.name);
+      }
+      index = block.endIndex;
+      continue;
+    }
+    const structMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)\b/);
+    if (structMatch) {
+      const exported = rustVisibilityPrefix(trimmed);
+      const block = collectBracedBlock(lines, index);
+      const symbol = {
+        name: structMatch[1],
+        kind: "class",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: block.text
+      };
+      draftSymbols.push(symbol);
+      symbolByName.set(symbol.name, symbol);
+      if (exported) {
+        exportLabels.push(symbol.name);
+      }
+      index = block.endIndex;
+      continue;
+    }
+    const enumMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)\b/);
+    if (enumMatch) {
+      const exported = rustVisibilityPrefix(trimmed);
+      const block = collectBracedBlock(lines, index);
+      const symbol = {
+        name: enumMatch[1],
+        kind: "enum",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: block.text
+      };
+      draftSymbols.push(symbol);
+      symbolByName.set(symbol.name, symbol);
+      if (exported) {
+        exportLabels.push(symbol.name);
+      }
+      index = block.endIndex;
+      continue;
+    }
+    const traitMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)\b/);
+    if (traitMatch) {
+      const exported = rustVisibilityPrefix(trimmed);
+      const block = collectBracedBlock(lines, index);
+      const symbol = {
+        name: traitMatch[1],
+        kind: "interface",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: block.text
+      };
+      draftSymbols.push(symbol);
+      symbolByName.set(symbol.name, symbol);
+      if (exported) {
+        exportLabels.push(symbol.name);
+      }
+      index = block.endIndex;
+      continue;
+    }
+    const aliasMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?type\s+([A-Za-z_]\w*)\s*=/);
+    if (aliasMatch) {
+      const exported = rustVisibilityPrefix(trimmed);
+      const symbol = {
+        name: aliasMatch[1],
+        kind: "type_alias",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: trimmed
+      };
+      draftSymbols.push(symbol);
+      symbolByName.set(symbol.name, symbol);
+      if (exported) {
+        exportLabels.push(symbol.name);
+      }
+      continue;
+    }
+    const variableMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?(?:const|static)\s+([A-Za-z_]\w*)\b/);
+    if (variableMatch) {
+      const exported = rustVisibilityPrefix(trimmed);
+      const symbol = {
+        name: variableMatch[1],
+        kind: "variable",
+        signature: singleLineSignature(trimmed),
+        exported,
+        callNames: [],
+        extendsNames: [],
+        implementsNames: [],
+        bodyText: trimmed
+      };
+      draftSymbols.push(symbol);
+      symbolByName.set(symbol.name, symbol);
+      if (exported) {
+        exportLabels.push(symbol.name);
+      }
+      continue;
+    }
+    const implMatch = trimmed.match(/^impl(?:<[^>]+>)?\s+(.+?)\s+for\s+([A-Za-z_][\w:<>]*)/);
+    if (implMatch) {
+      const traitName = normalizeSymbolReference(implMatch[1]);
+      const typeName = normalizeSymbolReference(implMatch[2]);
+      const symbol = symbolByName.get(typeName);
+      if (symbol && traitName) {
+        symbol.implementsNames.push(traitName);
+      }
+    }
+  }
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    const traitMatch = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)\b/);
+    if (!traitMatch || symbolByName.has(traitMatch[1])) {
+      continue;
+    }
+    const exported = rustVisibilityPrefix(trimmed);
+    const symbol = {
+      name: traitMatch[1],
+      kind: "interface",
+      signature: singleLineSignature(trimmed),
+      exported,
+      callNames: [],
+      extendsNames: [],
+      implementsNames: [],
+      bodyText: trimmed
+    };
+    draftSymbols.push(symbol);
+    symbolByName.set(symbol.name, symbol);
+    if (exported) {
+      exportLabels.push(symbol.name);
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "rust", imports, draftSymbols, exportLabels, diagnostics);
+}
+function analyzeJavaImport(statement) {
+  const cleaned = statement.replace(/^import\s+/, "").replace(/^static\s+/, "").replace(/;$/, "").trim();
+  const symbolName = normalizeSymbolReference(cleaned.replace(/\.\*$/, ""));
+  return {
+    specifier: cleaned.replace(/\.\*$/, ""),
+    importedSymbols: symbolName ? [symbolName] : [],
+    isExternal: true,
+    reExport: false
+  };
+}
+function parseJavaImplements(value) {
+  return (value ?? "").split(",").map((item) => normalizeSymbolReference(item)).filter(Boolean);
+}
+function analyzeJavaCode(manifest, content) {
+  const lines = splitLines(content);
+  const imports = [];
+  const draftSymbols = [];
+  const exportLabels = [];
+  const diagnostics = [];
+  let depth = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index] ?? "";
+    const trimmed = rawLine.trim();
+    const lineDepth = depth;
+    if (lineDepth === 0 && trimmed.startsWith("import ")) {
+      imports.push(analyzeJavaImport(trimmed));
+    }
+    if (lineDepth === 0) {
+      const classMatch = trimmed.match(
+        /^(public\s+)?(?:abstract\s+|final\s+|sealed\s+|non-sealed\s+)*class\s+([A-Za-z_]\w*)\b(?:\s+extends\s+([A-Za-z_][\w.<>]*))?(?:\s+implements\s+([A-Za-z_][\w.,<>\s]*))?/
+      );
+      if (classMatch) {
+        const exported = Boolean(classMatch[1]);
+        const block = collectBracedBlock(lines, index);
+        draftSymbols.push({
+          name: classMatch[2],
+          kind: "class",
+          signature: singleLineSignature(trimmed),
+          exported,
+          callNames: [],
+          extendsNames: classMatch[3] ? [classMatch[3]] : [],
+          implementsNames: parseJavaImplements(classMatch[4]),
+          bodyText: block.text
+        });
+        if (exported) {
+          exportLabels.push(classMatch[2]);
+        }
+        index = block.endIndex;
+        depth = 0;
+        continue;
+      }
+      const interfaceMatch = trimmed.match(
+        /^(public\s+)?(?:sealed\s+|non-sealed\s+)?interface\s+([A-Za-z_]\w*)\b(?:\s+extends\s+([A-Za-z_][\w.,<>\s]*))?/
+      );
+      if (interfaceMatch) {
+        const exported = Boolean(interfaceMatch[1]);
+        const block = collectBracedBlock(lines, index);
+        draftSymbols.push({
+          name: interfaceMatch[2],
+          kind: "interface",
+          signature: singleLineSignature(trimmed),
+          exported,
+          callNames: [],
+          extendsNames: parseJavaImplements(interfaceMatch[3]),
+          implementsNames: [],
+          bodyText: block.text
+        });
+        if (exported) {
+          exportLabels.push(interfaceMatch[2]);
+        }
+        index = block.endIndex;
+        depth = 0;
+        continue;
+      }
+      const enumMatch = trimmed.match(/^(public\s+)?enum\s+([A-Za-z_]\w*)\b(?:\s+implements\s+([A-Za-z_][\w.,<>\s]*))?/);
+      if (enumMatch) {
+        const exported = Boolean(enumMatch[1]);
+        const block = collectBracedBlock(lines, index);
+        draftSymbols.push({
+          name: enumMatch[2],
+          kind: "enum",
+          signature: singleLineSignature(trimmed),
+          exported,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: parseJavaImplements(enumMatch[3]),
+          bodyText: block.text
+        });
+        if (exported) {
+          exportLabels.push(enumMatch[2]);
+        }
+        index = block.endIndex;
+        depth = 0;
+        continue;
+      }
+      const recordMatch = trimmed.match(
+        /^(public\s+)?record\s+([A-Za-z_]\w*)\b(?:\s*\([^)]*\))?(?:\s+implements\s+([A-Za-z_][\w.,<>\s]*))?/
+      );
+      if (recordMatch) {
+        const exported = Boolean(recordMatch[1]);
+        const block = collectBracedBlock(lines, index);
+        draftSymbols.push({
+          name: recordMatch[2],
+          kind: "class",
+          signature: singleLineSignature(trimmed),
+          exported,
+          callNames: [],
+          extendsNames: [],
+          implementsNames: parseJavaImplements(recordMatch[3]),
+          bodyText: block.text
+        });
+        if (exported) {
+          exportLabels.push(recordMatch[2]);
+        }
+        index = block.endIndex;
+        depth = 0;
+        continue;
+      }
+    }
+    for (const character of rawLine) {
+      if (character === "{") {
+        depth += 1;
+      } else if (character === "}") {
+        depth -= 1;
+      }
+    }
+  }
+  return finalizeCodeAnalysis(manifest, "java", imports, draftSymbols, exportLabels, diagnostics);
+}
+function analyzeTypeScriptLikeCode(manifest, content) {
   const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType) ?? "typescript";
   const sourceFile = ts.createSourceFile(
     manifest.originalPath ?? manifest.storedPath,
@@ -478,17 +1201,6 @@ function analyzeTopLevelCode(manifest, content) {
       }
     }
   }
-  const seenSymbolIds = /* @__PURE__ */ new Map();
-  const symbols = draftSymbols.map((symbol) => ({
-    id: makeSymbolId(manifest.sourceId, symbol.name, seenSymbolIds),
-    name: symbol.name,
-    kind: symbol.kind,
-    signature: symbol.signature,
-    exported: symbol.exported || localExportNames.has(symbol.name),
-    calls: symbol.callNames,
-    extends: symbol.extendsNames,
-    implements: symbol.implementsNames
-  }));
   const parseDiagnostics = sourceFile.parseDiagnostics ?? [];
   const diagnostics = parseDiagnostics.map((diagnostic) => {
     const position = diagnostic.start !== void 0 ? sourceFile.getLineAndCharacterOfPosition(diagnostic.start) : void 0;
@@ -500,22 +1212,11 @@ function analyzeTopLevelCode(manifest, content) {
       column: (position?.character ?? 0) + 1
     };
   });
-  return {
-    moduleId: `module:${manifest.sourceId}`,
-    language,
-    imports,
-    dependencies: uniqueBy(
-      imports.filter((item) => item.isExternal).map((item) => item.specifier),
-      (specifier) => specifier
-    ),
-    symbols,
-    exports: uniqueBy([...symbols.filter((symbol) => symbol.exported).map((symbol) => symbol.name), ...exportLabels], (label) => label),
-    diagnostics
-  };
+  return finalizeCodeAnalysis(manifest, language, imports, draftSymbols, exportLabels, diagnostics);
 }
 function inferCodeLanguage(filePath, mimeType = "") {
   const extension = path2.extname(filePath).toLowerCase();
-  if (extension === ".ts") {
+  if (extension === ".ts" || extension === ".mts" || extension === ".cts") {
     return "typescript";
   }
   if (extension === ".tsx") {
@@ -524,35 +1225,92 @@ function inferCodeLanguage(filePath, mimeType = "") {
   if (extension === ".jsx") {
     return "jsx";
   }
-  if (extension === ".js" || mimeType.includes("javascript")) {
+  if (extension === ".js" || extension === ".mjs" || extension === ".cjs" || mimeType.includes("javascript")) {
     return "javascript";
   }
+  if (extension === ".py") {
+    return "python";
+  }
+  if (extension === ".go") {
+    return "go";
+  }
+  if (extension === ".rs") {
+    return "rust";
+  }
+  if (extension === ".java") {
+    return "java";
+  }
   return void 0;
 }
 function modulePageTitle(manifest) {
   return `${manifest.title} module`;
 }
-function importResolutionCandidates(basePath, specifier) {
+function importResolutionCandidates(basePath, specifier, extensions) {
   const resolved = path2.resolve(path2.dirname(basePath), specifier);
   if (path2.extname(resolved)) {
     return [path2.normalize(resolved)];
   }
-  const extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
   const direct = extensions.map((extension) => path2.normalize(`${resolved}${extension}`));
   const indexFiles = extensions.map((extension) => path2.normalize(path2.join(resolved, `index${extension}`)));
   return uniqueBy([path2.normalize(resolved), ...direct, ...indexFiles], (candidate) => candidate);
 }
-function resolveCodeImportSourceId(manifest, specifier, manifests) {
+function resolveJsLikeImportSourceId(manifest, specifier, manifests) {
   if (manifest.originType !== "file" || !manifest.originalPath || !isRelativeSpecifier(specifier)) {
     return void 0;
   }
-  const candidates = new Set(importResolutionCandidates(manifest.originalPath, specifier));
+  const candidates = new Set(
+    importResolutionCandidates(manifest.originalPath, specifier, [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"])
+  );
   return manifests.find(
     (candidate) => candidate.sourceKind === "code" && candidate.originalPath && candidates.has(path2.normalize(candidate.originalPath))
   )?.sourceId;
 }
+function resolvePythonImportSourceId(manifest, specifier, manifests) {
+  if (manifest.originType !== "file" || !manifest.originalPath) {
+    return void 0;
+  }
+  if (specifier.startsWith(".")) {
+    const dotMatch = specifier.match(/^\.+/);
+    const depth = dotMatch ? dotMatch[0].length : 0;
+    const relativeModule = specifier.slice(depth).replace(/\./g, "/");
+    const baseDir = path2.dirname(manifest.originalPath);
+    const parentDir = path2.resolve(baseDir, ...Array(Math.max(depth - 1, 0)).fill(".."));
+    const moduleBase = relativeModule ? path2.join(parentDir, relativeModule) : parentDir;
+    const candidates = /* @__PURE__ */ new Set([path2.normalize(`${moduleBase}.py`), path2.normalize(path2.join(moduleBase, "__init__.py"))]);
+    return manifests.find(
+      (candidate) => candidate.sourceKind === "code" && candidate.originalPath && candidates.has(path2.normalize(candidate.originalPath))
+    )?.sourceId;
+  }
+  const modulePath = specifier.replace(/\./g, "/");
+  const suffixes = [`/${modulePath}.py`, `/${modulePath}/__init__.py`];
+  return manifests.find((candidate) => {
+    if (candidate.sourceKind !== "code" || !candidate.originalPath) {
+      return false;
+    }
+    const normalizedOriginalPath = path2.normalize(candidate.originalPath);
+    return suffixes.some((suffix) => normalizedOriginalPath.endsWith(path2.normalize(suffix)));
+  })?.sourceId;
+}
+function resolveCodeImportSourceId(manifest, specifier, manifests) {
+  const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType);
+  switch (language) {
+    case "javascript":
+    case "jsx":
+    case "typescript":
+    case "tsx":
+      return resolveJsLikeImportSourceId(manifest, specifier, manifests);
+    case "python":
+      return resolvePythonImportSourceId(manifest, specifier, manifests);
+    default:
+      return void 0;
+  }
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function analyzeCodeSource(manifest, extractedText, schemaHash) {
-  const code = analyzeTopLevelCode(manifest, extractedText);
+  const language = manifest.language ?? inferCodeLanguage(manifest.originalPath ?? manifest.storedPath, manifest.mimeType) ?? "typescript";
+  const code = language === "python" ? analyzePythonCode(manifest, extractedText) : language === "go" ? analyzeGoCode(manifest, extractedText) : language === "rust" ? analyzeRustCode(manifest, extractedText) : language === "java" ? analyzeJavaCode(manifest, extractedText) : analyzeTypeScriptLikeCode(manifest, extractedText);
   return {
     sourceId: manifest.sourceId,
     sourceHash: manifest.contentHash,
@@ -2432,7 +3190,7 @@ function buildModulePage(input) {
   ]);
   const callsSection = code.symbols.flatMap((symbol) => symbol.calls.map((target) => `- \`${symbol.name}\` calls \`${target}\``));
   const diagnosticsSection = code.diagnostics.length ? code.diagnostics.map(
-    (diagnostic) => `- ${diagnostic.category} TS${diagnostic.code} at ${diagnostic.line}:${diagnostic.column}: ${diagnostic.message}`
+    (diagnostic) => `- ${diagnostic.category} diagnostic ${diagnostic.code} at ${diagnostic.line}:${diagnostic.column}: ${diagnostic.message}`
   ) : ["- No parser diagnostics."];
   const frontmatter = {
     page_id: pageId,
@@ -3827,7 +4585,7 @@ async function resolveImageGenerationProvider(rootDir) {
   if (!providerConfig) {
     throw new Error(`No provider configured with id "${preferredProviderId}" for task "imageProvider".`);
   }
-  const { createProvider: createProvider2 } = await import("./registry-2XHXZDGH.js");
+  const { createProvider: createProvider2 } = await import("./registry-YDXVCE4Q.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -6766,7 +7524,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.14";
+var SERVER_VERSION = "0.1.16";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",