bluera-knowledge 0.10.0 → 0.11.0

package/dist/{chunk-CUHYSPRV.js → chunk-565OVW3C.js}

@@ -1,16 +1,639 @@
 import {
+  AdapterRegistry,
   JobService,
+  ProjectRootService,
   createLogger,
   createServices,
   createStoreId,
   summarizePayload
-} from "./chunk-DWAIT2OD.js";
+} from "./chunk-TRDMYKGC.js";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
+// src/analysis/zil/zil-lexer.ts
+var ZilLexer = class {
+  input = "";
+  pos = 0;
+  line = 1;
+  column = 1;
+  tokens = [];
+  /**
+   * Tokenize ZIL source code
+   *
+   * @param input - Source code string
+   * @returns Array of tokens
+   * @throws On unterminated strings
+   */
+  tokenize(input) {
+    this.input = input;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+    this.tokens = [];
+    while (!this.isAtEnd()) {
+      this.scanToken();
+    }
+    return this.tokens;
+  }
+  isAtEnd() {
+    return this.pos >= this.input.length;
+  }
+  peek() {
+    if (this.isAtEnd()) return "\0";
+    return this.input[this.pos] ?? "\0";
+  }
+  advance() {
+    const char = this.input[this.pos] ?? "\0";
+    this.pos++;
+    if (char === "\n") {
+      this.line++;
+      this.column = 1;
+    } else {
+      this.column++;
+    }
+    return char;
+  }
+  addToken(type, value, startLine, startColumn) {
+    this.tokens.push({
+      type,
+      value,
+      line: startLine,
+      column: startColumn
+    });
+  }
+  scanToken() {
+    const startLine = this.line;
+    const startColumn = this.column;
+    const char = this.advance();
+    switch (char) {
+      case "<":
+        this.addToken("LANGLE" /* LANGLE */, "<", startLine, startColumn);
+        break;
+      case ">":
+        this.addToken("RANGLE" /* RANGLE */, ">", startLine, startColumn);
+        break;
+      case "(":
+        this.addToken("LPAREN" /* LPAREN */, "(", startLine, startColumn);
+        break;
+      case ")":
+        this.addToken("RPAREN" /* RPAREN */, ")", startLine, startColumn);
+        break;
+      case '"':
+        this.scanString(startLine, startColumn);
+        break;
+      case ";":
+        this.skipComment();
+        break;
+      case " ":
+      case "	":
+      case "\r":
+      case "\n":
+        break;
+      default:
+        if (this.isDigit(char) || char === "-" && this.isDigit(this.peek())) {
+          this.scanNumber(char, startLine, startColumn);
+        } else if (this.isAtomStart(char)) {
+          this.scanAtom(char, startLine, startColumn);
+        }
+        break;
+    }
+  }
+  scanString(startLine, startColumn) {
+    let value = "";
+    while (!this.isAtEnd() && this.peek() !== '"') {
+      const char = this.peek();
+      if (char === "\\") {
+        this.advance();
+        const escaped = this.advance();
+        switch (escaped) {
+          case '"':
+            value += '"';
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case "n":
+            value += "\n";
+            break;
+          case "t":
+            value += "	";
+            break;
+          default:
+            value += escaped;
+            break;
+        }
+      } else {
+        value += this.advance();
+      }
+    }
+    if (this.isAtEnd()) {
+      throw new Error(
+        `Unterminated string at line ${String(startLine)}, column ${String(startColumn)}`
+      );
+    }
+    this.advance();
+    this.addToken("STRING" /* STRING */, value, startLine, startColumn);
+  }
+  scanNumber(firstChar, startLine, startColumn) {
+    let value = firstChar;
+    while (this.isDigit(this.peek())) {
+      value += this.advance();
+    }
+    this.addToken("NUMBER" /* NUMBER */, value, startLine, startColumn);
+  }
+  scanAtom(firstChar, startLine, startColumn) {
+    let value = firstChar;
+    while (this.isAtomChar(this.peek())) {
+      value += this.advance();
+    }
+    this.addToken("ATOM" /* ATOM */, value, startLine, startColumn);
+  }
+  skipComment() {
+    while (!this.isAtEnd() && this.peek() !== "\n") {
+      this.advance();
+    }
+  }
+  isDigit(char) {
+    return char >= "0" && char <= "9";
+  }
+  isAtomStart(char) {
+    return char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char === "_" || char === "," || // Global reference prefix
+    char === "." || // Local reference prefix
+    char === "%" || // Sometimes used in ZIL
+    char === "#";
+  }
+  isAtomChar(char) {
+    return char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char >= "0" && char <= "9" || char === "_" || char === "-" || char === "?" || char === "!" || char === "," || char === "." || char === "%" || char === "#";
+  }
+};
+
+// src/analysis/zil/zil-special-forms.ts
+var ZIL_SPECIAL_FORMS = /* @__PURE__ */ new Set([
+  // Conditionals
+  "COND",
+  "AND",
+  "OR",
+  "NOT",
+  "IF",
+  "ELSE",
+  // Assignment
+  "SET",
+  "SETG",
+  "BIND",
+  "PROG",
+  // Loops
+  "REPEAT",
+  "DO",
+  "MAP",
+  "MAPF",
+  "MAPR",
+  "MAPRET",
+  "MAPLEAVE",
+  // Output
+  "TELL",
+  "PRINT",
+  "PRINTN",
+  "PRINTD",
+  "PRINTC",
+  "PRINTR",
+  "CRLF",
+  // Control flow
+  "RETURN",
+  "AGAIN",
+  "RTRUE",
+  "RFALSE",
+  "QUIT",
+  // Predicates (end with ?)
+  "EQUAL?",
+  "ZERO?",
+  "LESS?",
+  "GRTR?",
+  "FSET?",
+  "IN?",
+  "VERB?",
+  "PRSO?",
+  "PRSI?",
+  "HELD?",
+  "HERE?",
+  "ACCESSIBLE?",
+  "VISIBLE?",
+  "FIRST?",
+  "NEXT?",
+  "PROB?",
+  "RANDOM",
+  // Property/flag manipulation
+  "FSET",
+  "FCLEAR",
+  "GETP",
+  "PUTP",
+  "GETPT",
+  "PTSIZE",
+  // Object manipulation
+  "MOVE",
+  "REMOVE",
+  "LOC",
+  "FIRST",
+  "NEXT",
+  // Arithmetic
+  "ADD",
+  "SUB",
+  "MUL",
+  "DIV",
+  "MOD",
+  "BAND",
+  "BOR",
+  "BCOM",
+  "LSH",
+  // Table operations
+  "GET",
+  "PUT",
+  "GETB",
+  "PUTB",
+  "TABLE",
+  "ITABLE",
+  "LTABLE",
+  "PTABLE",
+  // Stack operations
+  "PUSH",
+  "POP",
+  "FSTACK",
+  // Input
+  "READ",
+  "INPUT",
+  "READLINE",
+  // Definition forms (handled separately for symbol extraction)
+  "ROUTINE",
+  "OBJECT",
+  "ROOM",
+  "GLOBAL",
+  "CONSTANT",
+  "SYNTAX",
+  "INSERT-FILE",
+  // Misc builtins
+  "VERSION?",
+  "ASCII",
+  "USL",
+  "APPLY",
+  "EVAL",
+  "FORM",
+  "REST",
+  "LENGTH",
+  "NTH",
+  "ZGET",
+  "ZPUT",
+  "ZWSTR",
+  "DIROUT",
+  "DIRIN",
+  "BUFOUT",
+  "HLIGHT",
+  "COLOR",
+  "FONT",
+  "SPLIT",
+  "SCREEN",
+  "WINGET",
+  "WINPUT",
+  "WINATTR",
+  "PICINF",
+  "DISPLAY",
+  "DCLEAR",
+  "SOUND",
+  "INTBL?",
+  "CATCH",
+  "THROW",
+  "LEGAL?",
+  "COPYT",
+  "VALUE",
+  "GASSIGNED?",
+  "ASSIGNED?",
+  "DEFINE",
+  "DEFMAC"
+]);
+function isSpecialForm(name) {
+  return ZIL_SPECIAL_FORMS.has(name.toUpperCase());
+}
+var ZIL_DEFINITION_FORMS = /* @__PURE__ */ new Set([
+  "ROUTINE",
+  "OBJECT",
+  "ROOM",
+  "GLOBAL",
+  "CONSTANT",
+  "SYNTAX",
+  "VERB",
+  "DEFINE",
+  "DEFMAC"
+]);
+function isDefinitionForm(name) {
+  return ZIL_DEFINITION_FORMS.has(name.toUpperCase());
+}
+
+// src/analysis/zil/zil-parser.ts
+var ZilParser = class {
+  lexer = new ZilLexer();
+  tokens = [];
+  pos = 0;
+  /**
+   * Parse ZIL source code
+   */
+  parse(input) {
+    this.tokens = this.lexer.tokenize(input);
+    this.pos = 0;
+    const forms = [];
+    const symbols = [];
+    const imports = [];
+    const calls = [];
+    while (!this.isAtEnd()) {
+      if (this.check("LANGLE" /* LANGLE */)) {
+        const form = this.parseForm();
+        if (form !== void 0) {
+          forms.push(form);
+          const symbol = this.extractSymbol(form);
+          if (symbol !== void 0) {
+            symbols.push(symbol);
+          }
+          const imp = this.extractImport(form);
+          if (imp !== void 0) {
+            imports.push(imp);
+          }
+          if (form.head.toUpperCase() === "ROUTINE") {
+            const routineName = this.getRoutineName(form);
+            if (routineName !== void 0) {
+              this.extractCalls(form, routineName, calls);
+            }
+          }
+        }
+      } else {
+        this.advance();
+      }
+    }
+    return { forms, symbols, imports, calls };
+  }
+  isAtEnd() {
+    return this.pos >= this.tokens.length;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  check(type) {
+    if (this.isAtEnd()) return false;
+    return this.peek()?.type === type;
+  }
+  advance() {
+    if (!this.isAtEnd()) {
+      const token = this.tokens[this.pos];
+      this.pos++;
+      return token;
+    }
+    return void 0;
+  }
+  parseForm() {
+    if (!this.check("LANGLE" /* LANGLE */)) return void 0;
+    const startToken = this.advance();
+    const startLine = startToken?.line ?? 1;
+    let endLine = startLine;
+    let head = "";
+    if (this.check("ATOM" /* ATOM */)) {
+      head = this.advance()?.value ?? "";
+    }
+    const children = [];
+    while (!this.isAtEnd() && !this.check("RANGLE" /* RANGLE */)) {
+      const child = this.parseNode();
+      if (child !== void 0) {
+        children.push(child);
+        endLine = this.getNodeEndLine(child);
+      } else {
+        this.advance();
+      }
+    }
+    if (this.check("RANGLE" /* RANGLE */)) {
+      const closeToken = this.advance();
+      endLine = closeToken?.line ?? endLine;
+    }
+    return { head, children, startLine, endLine };
+  }
+  parseGroup() {
+    if (!this.check("LPAREN" /* LPAREN */)) return void 0;
+    const startToken = this.advance();
+    const startLine = startToken?.line ?? 1;
+    let endLine = startLine;
+    const children = [];
+    while (!this.isAtEnd() && !this.check("RPAREN" /* RPAREN */)) {
+      const child = this.parseNode();
+      if (child !== void 0) {
+        children.push(child);
+        endLine = this.getNodeEndLine(child);
+      } else {
+        this.advance();
+      }
+    }
+    if (this.check("RPAREN" /* RPAREN */)) {
+      const closeToken = this.advance();
+      endLine = closeToken?.line ?? endLine;
+    }
+    return { type: "group", children, startLine, endLine };
+  }
+  parseNode() {
+    const token = this.peek();
+    if (token === void 0) return void 0;
+    switch (token.type) {
+      case "LANGLE" /* LANGLE */:
+        return this.parseForm();
+      case "LPAREN" /* LPAREN */:
+        return this.parseGroup();
+      case "ATOM" /* ATOM */:
+        this.advance();
+        return { type: "atom", value: token.value, line: token.line };
+      case "STRING" /* STRING */:
+        this.advance();
+        return { type: "string", value: token.value, line: token.line };
+      case "NUMBER" /* NUMBER */:
+        this.advance();
+        return { type: "number", value: token.value, line: token.line };
+      default:
+        return void 0;
+    }
+  }
+  getNodeEndLine(node) {
+    if ("endLine" in node) {
+      return node.endLine;
+    }
+    return node.line;
+  }
+  extractSymbol(form) {
+    const headUpper = form.head.toUpperCase();
+    if (!isDefinitionForm(headUpper)) {
+      return void 0;
+    }
+    const nameNode = form.children.find((c) => "type" in c && c.type === "atom");
+    if (nameNode === void 0) {
+      return void 0;
+    }
+    const kindMap = {
+      ROUTINE: "routine",
+      OBJECT: "object",
+      ROOM: "room",
+      GLOBAL: "global",
+      CONSTANT: "constant",
+      SYNTAX: "syntax",
+      VERB: "verb",
+      DEFINE: "routine",
+      DEFMAC: "routine"
+    };
+    const kind = kindMap[headUpper];
+    if (kind === void 0) {
+      return void 0;
+    }
+    const result = {
+      name: nameNode.value,
+      kind,
+      startLine: form.startLine,
+      endLine: form.endLine
+    };
+    if (headUpper === "ROUTINE" || headUpper === "DEFINE" || headUpper === "DEFMAC") {
+      result.signature = this.extractRoutineSignature(form, nameNode.value);
+    }
+    return result;
+  }
+  extractRoutineSignature(form, name) {
+    const argsGroup = form.children.find((c) => "type" in c && c.type === "group");
+    if (argsGroup === void 0) {
+      return `ROUTINE ${name} ()`;
+    }
+    const args = argsGroup.children.filter((c) => "type" in c && c.type === "atom").map((c) => c.value).join(" ");
+    return `ROUTINE ${name} (${args})`;
+  }
+  extractImport(form) {
+    if (form.head.toUpperCase() !== "INSERT-FILE") {
+      return void 0;
+    }
+    const fileNode = form.children.find((c) => "type" in c && c.type === "string");
+    if (fileNode === void 0) {
+      return void 0;
+    }
+    return {
+      source: fileNode.value,
+      specifiers: [],
+      isType: false
+    };
+  }
+  getRoutineName(form) {
+    const nameNode = form.children.find((c) => "type" in c && c.type === "atom");
+    return nameNode?.value;
+  }
+  extractCalls(node, caller, calls) {
+    if ("head" in node) {
+      const headUpper = node.head.toUpperCase();
+      if (node.head !== "" && !isSpecialForm(headUpper)) {
+        calls.push({
+          caller,
+          callee: node.head,
+          line: node.startLine
+        });
+      }
+      for (const child of node.children) {
+        this.extractCalls(child, caller, calls);
+      }
+    } else if ("type" in node && node.type === "group") {
+      for (const child of node.children) {
+        this.extractCalls(child, caller, calls);
+      }
+    }
+  }
+};
+
+// src/analysis/zil/zil-adapter.ts
+var ZilAdapter = class {
+  languageId = "zil";
+  extensions = [".zil", ".mud"];
+  displayName = "ZIL (Zork Implementation Language)";
+  parser = new ZilParser();
+  /**
+   * Parse ZIL code and extract symbols as CodeNode[]
+   */
+  parse(content, _filePath) {
+    const result = this.parser.parse(content);
+    return result.symbols.map((symbol) => {
+      const node = {
+        type: this.mapSymbolKindToNodeType(symbol.kind),
+        name: symbol.name,
+        exported: true,
+        // ZIL doesn't have export concept, treat all as exported
+        startLine: symbol.startLine,
+        endLine: symbol.endLine
+      };
+      if (symbol.signature !== void 0) {
+        node.signature = symbol.signature;
+      }
+      return node;
+    });
+  }
+  /**
+   * Extract imports from INSERT-FILE directives
+   */
+  extractImports(content, _filePath) {
+    const result = this.parser.parse(content);
+    return result.imports;
+  }
+  /**
+   * Chunk ZIL code by top-level forms
+   */
+  chunk(content, _filePath) {
+    const result = this.parser.parse(content);
+    const lines = content.split("\n");
+    return result.forms.filter((form) => form.head !== "").map((form) => {
+      const chunkLines = lines.slice(form.startLine - 1, form.endLine);
+      const chunkContent = chunkLines.join("\n");
+      const symbol = result.symbols.find(
+        (s) => s.startLine === form.startLine && s.endLine === form.endLine
+      );
+      const chunk = {
+        content: chunkContent,
+        startLine: form.startLine,
+        endLine: form.endLine
+      };
+      if (symbol !== void 0) {
+        chunk.symbolName = symbol.name;
+        chunk.symbolKind = symbol.kind;
+      }
+      return chunk;
+    });
+  }
+  /**
+   * Analyze call relationships within ZIL code
+   */
+  analyzeCallRelationships(content, filePath) {
+    const result = this.parser.parse(content);
+    return result.calls.map((call) => ({
+      from: `${filePath}:${call.caller}`,
+      to: `${filePath}:${call.callee}`,
+      type: "calls",
+      confidence: 0.9
+      // High confidence for ZIL - calls are explicit
+    }));
+  }
+  /**
+   * Map ZIL symbol kinds to CodeNode types
+   */
+  mapSymbolKindToNodeType(kind) {
+    switch (kind) {
+      case "routine":
+        return "function";
+      case "object":
+      case "room":
+      case "global":
+      case "constant":
+        return "const";
+      case "syntax":
+      case "verb":
+        return "const";
+      default:
+        return "const";
+    }
+  }
+};
+
 // src/mcp/commands/job.commands.ts
 import { z as z2 } from "zod";
 
@@ -599,10 +1222,375 @@ var storeCommands = [
   }
 ];
 
+// src/mcp/commands/sync.commands.ts
+import { z as z7 } from "zod";
+
+// src/services/store-definition.service.ts
+import { readFile, writeFile, mkdir, access } from "fs/promises";
+import { dirname, resolve, isAbsolute, join as join2 } from "path";
+
+// src/types/store-definition.ts
+import { z as z6 } from "zod";
+var BaseStoreDefinitionSchema = z6.object({
+  name: z6.string().min(1, "Store name is required"),
+  description: z6.string().optional(),
+  tags: z6.array(z6.string()).optional()
+});
+var FileStoreDefinitionSchema = BaseStoreDefinitionSchema.extend({
+  type: z6.literal("file"),
+  path: z6.string().min(1, "Path is required for file stores")
+});
+var RepoStoreDefinitionSchema = BaseStoreDefinitionSchema.extend({
+  type: z6.literal("repo"),
+  url: z6.url("Valid URL is required for repo stores"),
+  branch: z6.string().optional(),
+  depth: z6.number().int().positive("Depth must be a positive integer").optional()
+});
+var WebStoreDefinitionSchema = BaseStoreDefinitionSchema.extend({
+  type: z6.literal("web"),
+  url: z6.url("Valid URL is required for web stores"),
+  depth: z6.number().int().min(0, "Depth must be non-negative").default(1),
+  maxPages: z6.number().int().positive("maxPages must be a positive integer").optional(),
+  crawlInstructions: z6.string().optional(),
+  extractInstructions: z6.string().optional()
+});
+var StoreDefinitionSchema = z6.discriminatedUnion("type", [
+  FileStoreDefinitionSchema,
+  RepoStoreDefinitionSchema,
+  WebStoreDefinitionSchema
+]);
+var StoreDefinitionsConfigSchema = z6.object({
+  version: z6.literal(1),
+  stores: z6.array(StoreDefinitionSchema)
+});
+function isFileStoreDefinition(def) {
+  return def.type === "file";
+}
+function isRepoStoreDefinition(def) {
+  return def.type === "repo";
+}
+function isWebStoreDefinition(def) {
+  return def.type === "web";
+}
+var DEFAULT_STORE_DEFINITIONS_CONFIG = {
+  version: 1,
+  stores: []
+};
+
+// src/services/store-definition.service.ts
+async function fileExists(path2) {
+  try {
+    await access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var StoreDefinitionService = class {
+  configPath;
+  projectRoot;
+  config = null;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot ?? ProjectRootService.resolve();
+    this.configPath = join2(this.projectRoot, ".bluera/bluera-knowledge/stores.config.json");
+  }
+  /**
+   * Load store definitions from config file.
+   * Returns empty config if file doesn't exist.
+   * Throws on parse/validation errors (fail fast per CLAUDE.md).
+   */
+  async load() {
+    if (this.config !== null) {
+      return this.config;
+    }
+    const exists = await fileExists(this.configPath);
+    if (!exists) {
+      this.config = {
+        ...DEFAULT_STORE_DEFINITIONS_CONFIG,
+        stores: [...DEFAULT_STORE_DEFINITIONS_CONFIG.stores]
+      };
+      return this.config;
+    }
+    const content = await readFile(this.configPath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse store definitions at ${this.configPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const result = StoreDefinitionsConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      throw new Error(`Invalid store definitions at ${this.configPath}: ${result.error.message}`);
+    }
+    this.config = result.data;
+    return this.config;
+  }
+  /**
+   * Save store definitions to config file.
+   */
+  async save(config) {
+    await mkdir(dirname(this.configPath), { recursive: true });
+    await writeFile(this.configPath, JSON.stringify(config, null, 2));
+    this.config = config;
+  }
+  /**
+   * Add a store definition.
+   * Throws if a definition with the same name already exists.
+   */
+  async addDefinition(definition) {
+    const config = await this.load();
+    const existing = config.stores.find((s) => s.name === definition.name);
+    if (existing !== void 0) {
+      throw new Error(`Store definition "${definition.name}" already exists`);
+    }
+    config.stores.push(definition);
+    await this.save(config);
+  }
+  /**
+   * Remove a store definition by name.
+   * Returns true if removed, false if not found.
+   */
+  async removeDefinition(name) {
+    const config = await this.load();
+    const index = config.stores.findIndex((s) => s.name === name);
+    if (index === -1) {
+      return false;
+    }
+    config.stores.splice(index, 1);
+    await this.save(config);
+    return true;
+  }
+  /**
+   * Update an existing store definition.
+   * Only updates the provided fields, preserving others.
+   * Throws if definition not found.
+   */
+  async updateDefinition(name, updates) {
+    const config = await this.load();
+    const index = config.stores.findIndex((s) => s.name === name);
+    if (index === -1) {
+      throw new Error(`Store definition "${name}" not found`);
+    }
+    const existing = config.stores[index];
+    if (existing === void 0) {
+      throw new Error(`Store definition "${name}" not found at index ${String(index)}`);
+    }
+    if (updates.description !== void 0) {
+      existing.description = updates.description;
+    }
+    if (updates.tags !== void 0) {
+      existing.tags = updates.tags;
+    }
+    await this.save(config);
+  }
+  /**
+   * Get a store definition by name.
+   * Returns undefined if not found.
+   */
+  async getByName(name) {
+    const config = await this.load();
+    return config.stores.find((s) => s.name === name);
+  }
+  /**
+   * Check if any definitions exist.
+   */
+  async hasDefinitions() {
+    const config = await this.load();
+    return config.stores.length > 0;
+  }
+  /**
+   * Resolve a file store path relative to project root.
+   */
+  resolvePath(path2) {
+    if (isAbsolute(path2)) {
+      return path2;
+    }
+    return resolve(this.projectRoot, path2);
+  }
+  /**
+   * Get the config file path.
+   */
+  getConfigPath() {
+    return this.configPath;
+  }
+  /**
+   * Get the project root.
+   */
+  getProjectRoot() {
+    return this.projectRoot;
+  }
+  /**
+   * Clear the cached config (useful for testing).
+   */
+  clearCache() {
+    this.config = null;
+  }
+};
+
+// src/mcp/commands/sync.commands.ts
+async function handleStoresSync(args, context) {
+  const { services, options } = context;
+  const projectRoot = options.projectRoot;
+  if (projectRoot === void 0) {
+    throw new Error("Project root is required for stores:sync");
+  }
+  const defService = new StoreDefinitionService(projectRoot);
+  const config = await defService.load();
+  const result = {
+    created: [],
+    skipped: [],
+    failed: [],
+    orphans: []
+  };
+  if (args.dryRun === true) {
+    result.dryRun = true;
+    result.wouldCreate = [];
+    result.wouldPrune = [];
+  }
+  const existingStores = await services.store.list();
+  const existingNames = new Set(existingStores.map((s) => s.name));
+  for (const def of config.stores) {
+    if (existingNames.has(def.name)) {
+      result.skipped.push(def.name);
+      continue;
+    }
+    if (args.dryRun === true) {
+      result.wouldCreate?.push(def.name);
+      continue;
+    }
+    const createResult = await createStoreFromDefinition(def, defService, services, context);
+    if (createResult.success) {
+      result.created.push(def.name);
+    } else {
+      result.failed.push({ name: def.name, error: createResult.error });
+    }
+  }
+  const definedNames = new Set(config.stores.map((d) => d.name));
+  for (const store of existingStores) {
+    if (!definedNames.has(store.name)) {
+      result.orphans.push(store.name);
+    }
+  }
+  if (args.prune === true && result.orphans.length > 0) {
+    if (args.dryRun === true) {
+      result.wouldPrune = [...result.orphans];
+    } else {
+      result.pruned = [];
+      for (const orphanName of result.orphans) {
+        const store = await services.store.getByName(orphanName);
+        if (store !== void 0) {
+          const deleteResult = await services.store.delete(store.id, { skipDefinitionSync: true });
+          if (deleteResult.success) {
+            result.pruned.push(orphanName);
+          }
+        }
+      }
+    }
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+async function createStoreFromDefinition(def, defService, services, _context) {
+  try {
+    if (isFileStoreDefinition(def)) {
+      const resolvedPath = defService.resolvePath(def.path);
+      const createResult = await services.store.create(
+        {
+          name: def.name,
+          type: "file",
+          path: resolvedPath,
+          description: def.description,
+          tags: def.tags
+        },
+        { skipDefinitionSync: true }
+        // Don't re-add to definitions
+      );
+      if (!createResult.success) {
+        return { success: false, error: createResult.error.message };
+      }
+      return { success: true };
+    }
+    if (isRepoStoreDefinition(def)) {
+      const createResult = await services.store.create(
+        {
+          name: def.name,
+          type: "repo",
+          url: def.url,
+          branch: def.branch,
+          depth: def.depth,
+          description: def.description,
+          tags: def.tags
+        },
+        { skipDefinitionSync: true }
+      );
+      if (!createResult.success) {
+        return { success: false, error: createResult.error.message };
+      }
+      return { success: true };
+    }
+    if (isWebStoreDefinition(def)) {
+      const createResult = await services.store.create(
+        {
+          name: def.name,
+          type: "web",
+          url: def.url,
+          depth: def.depth,
+          description: def.description,
+          tags: def.tags
+        },
+        { skipDefinitionSync: true }
+      );
+      if (!createResult.success) {
+        return { success: false, error: createResult.error.message };
+      }
+      return { success: true };
+    }
+    return { success: false, error: "Unknown store definition type" };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var syncCommands = [
+  {
+    name: "stores:sync",
+    description: "Sync stores from definitions config (bootstrap on fresh clone)",
+    argsSchema: z7.object({
+      reindex: z7.boolean().optional().describe("Re-index existing stores after sync"),
+      prune: z7.boolean().optional().describe("Remove stores not in definitions"),
+      dryRun: z7.boolean().optional().describe("Show what would happen without making changes")
+    }),
+    handler: (args, context) => {
+      const syncArgs = {};
+      if (typeof args["reindex"] === "boolean") {
+        syncArgs.reindex = args["reindex"];
+      }
+      if (typeof args["prune"] === "boolean") {
+        syncArgs.prune = args["prune"];
+      }
+      if (typeof args["dryRun"] === "boolean") {
+        syncArgs.dryRun = args["dryRun"];
+      }
+      return handleStoresSync(syncArgs, context);
+    }
+  }
+];
+
 // src/mcp/commands/index.ts
 commandRegistry.registerAll(storeCommands);
 commandRegistry.registerAll(jobCommands);
 commandRegistry.registerAll(metaCommands);
+commandRegistry.registerAll(syncCommands);
 
 // src/mcp/handlers/execute.handler.ts
 var handleExecute = async (args, context) => {
@@ -927,6 +1915,10 @@ var tools = [
 
 // src/mcp/server.ts
 var logger2 = createLogger("mcp-server");
+var registry = AdapterRegistry.getInstance();
+if (!registry.hasExtension(".zil")) {
+  registry.register(new ZilAdapter());
+}
 function createMCPServer(options) {
   const server = new Server(
     {
@@ -1092,7 +2084,12 @@ if (isMCPServerEntry) {
 }
 
 export {
+  ZilAdapter,
+  isFileStoreDefinition,
+  isRepoStoreDefinition,
+  isWebStoreDefinition,
+  StoreDefinitionService,
   createMCPServer,
   runMCPServer
 };
-//# sourceMappingURL=chunk-CUHYSPRV.js.map
+//# sourceMappingURL=chunk-565OVW3C.js.map