musubix2 0.5.7 → 0.5.9

package/dist/cli.js

@@ -13836,108 +13836,139 @@ function fail(error) {
 }
 function sddCoreTools() {
   return [
-    tool("sdd.requirements.create", "Create an EARS requirement (Easy Approach to Requirements Syntax)", "sdd-core", [
-      param("pattern", "string", "EARS pattern: ubiquitous | event-driven | unwanted | state-driven | optional"),
-      param("text", "string", "Requirement text"),
+    tool("sdd.requirements.create", "Create and classify an EARS requirement (Easy Approach to Requirements Syntax)", "sdd-core", [
+      param("text", "string", "Requirement text (EARS sentence)"),
       param("id", "string", "Requirement ID", false)
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const req = core.createRequirement?.({
-          pattern: params["pattern"],
-          text: params["text"],
-          id: params["id"]
+        const { createEARSValidator: createEARSValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const v = createEARSValidator2();
+        const text = params["text"];
+        const analysis = v.analyze(text);
+        const validation = v.validate(text);
+        return ok({
+          id: params["id"] ?? "REQ-XXX-001",
+          text,
+          pattern: analysis.pattern,
+          confidence: analysis.confidence,
+          valid: validation.valid,
+          issues: validation.issues
         });
-        return ok(req ?? { pattern: params["pattern"], text: params["text"], id: params["id"] ?? "REQ-001" });
       } catch {
-        return ok({ pattern: params["pattern"], text: params["text"], id: params["id"] ?? "REQ-001" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.requirements.validate", "Validate requirements for completeness and consistency", "sdd-core", [param("requirements", "array", "Array of requirement objects to validate")], async (params) => {
+    tool("sdd.requirements.validate", "Validate requirements (EARS pattern + issues) for a list of requirement texts", "sdd-core", [param("requirements", "array", "Array of requirement texts or {text} objects")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.validateRequirements?.(params["requirements"]);
-        return ok(result ?? { valid: true, issues: [] });
+        const { createEARSValidator: createEARSValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const v = createEARSValidator2();
+        const items = params["requirements"] ?? [];
+        const results = items.map((it) => {
+          const text = typeof it === "string" ? it : it.text ?? "";
+          const analysis = v.analyze(text);
+          const validation = v.validate(text);
+          return { text, pattern: analysis.pattern, valid: validation.valid, issues: validation.issues };
+        });
+        return ok({ results, allValid: results.every((r) => r.valid) });
       } catch {
-        return ok({ valid: true, issues: [] });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.requirements.list", "List all requirements in the current project", "sdd-core", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("sdd.requirements.list", "Parse and list requirements from a Markdown requirements document", "sdd-core", [param("markdown", "string", "Requirements document contents (Markdown)")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const list = core.listRequirements?.(params["basePath"] ?? ".");
-        return ok(list ?? []);
+        const { MarkdownEARSParser: MarkdownEARSParser2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const parsed = new MarkdownEARSParser2().parse(params["markdown"] ?? "");
+        return ok(parsed.map((r) => ({ id: r.id, title: r.title, pattern: r.pattern, text: r.text })));
       } catch {
-        return ok([]);
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.design.generate", "Generate a design document from requirements", "sdd-core", [
-      param("requirements", "array", "Requirements to generate design from"),
-      param("format", "string", "Output format: markdown | json", false, "markdown")
-    ], async (params) => {
+    tool("sdd.design.generate", "Generate a design document from parsed requirements", "sdd-core", [param("requirements", "array", "Requirements as {id,title,text,pattern} objects")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const design = core.generateDesign?.({
-          requirements: params["requirements"],
-          format: params["format"] ?? "markdown"
-        });
-        return ok(design ?? { sections: [], format: params["format"] ?? "markdown" });
+        const { createDesignGenerator: createDesignGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const reqs = params["requirements"] ?? [];
+        const mapped = reqs.map((r) => ({
+          id: String(r["id"] ?? "REQ-XXX-001"),
+          title: String(r["title"] ?? ""),
+          text: String(r["text"] ?? ""),
+          pattern: String(r["pattern"] ?? "ubiquitous")
+        }));
+        return ok(createDesignGenerator2().generate(mapped));
       } catch {
-        return ok({ sections: [], format: params["format"] ?? "markdown" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.design.verify", "Verify design traceability back to requirements", "sdd-core", [
-      param("design", "object", "Design document to verify"),
-      param("requirements", "array", "Requirements to trace against")
-    ], async (params) => {
+    tool("sdd.design.verify", "Verify a design against SOLID principles", "sdd-core", [param("requirements", "array", "Requirements the design is generated from")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.verifyTraceability?.({
-          design: params["design"],
-          requirements: params["requirements"]
-        });
-        return ok(result ?? { complete: true, gaps: [] });
+        const { createDesignGenerator: createDesignGenerator2, createSOLIDValidator: createSOLIDValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const reqs = params["requirements"] ?? [];
+        const mapped = reqs.map((r) => ({
+          id: String(r["id"] ?? "REQ-XXX-001"),
+          title: String(r["title"] ?? ""),
+          text: String(r["text"] ?? ""),
+          pattern: String(r["pattern"] ?? "ubiquitous")
+        }));
+        const design = createDesignGenerator2().generate(mapped);
+        return ok(createSOLIDValidator2().validate(design));
       } catch {
-        return ok({ complete: true, gaps: [] });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.codegen.generate", "Generate code from a design document", "sdd-core", [
-      param("design", "object", "Design document"),
-      param("language", "string", "Target language: typescript | python", false, "typescript")
+    tool("sdd.codegen.generate", "Generate a code skeleton (class/interface/function) from a name", "sdd-core", [
+      param("name", "string", "Symbol name to generate"),
+      param("templateType", "string", "class | interface | function | enum | type", false, "class"),
+      param("description", "string", "Doc description", false)
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const code = core.generateCode?.({
-          design: params["design"],
-          language: params["language"] ?? "typescript"
+        const { createCodeGenerator: createCodeGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const code = createCodeGenerator2().generate({
+          templateType: params["templateType"] ?? "class",
+          name: params["name"] ?? "Generated",
+          description: params["description"]
         });
-        return ok(code ?? { files: [], language: params["language"] ?? "typescript" });
+        return ok(code);
       } catch {
-        return ok({ files: [], language: params["language"] ?? "typescript" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.test.generate", "Generate tests from a design document", "sdd-core", [
-      param("design", "object", "Design document"),
-      param("framework", "string", "Test framework: vitest | jest | pytest", false, "vitest")
+    tool("sdd.test.generate", "Generate a unit-test skeleton from source code", "sdd-core", [
+      param("code", "string", "Source code to generate tests for"),
+      param("style", "string", "Test style: unit | integration", false, "unit")
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const tests = core.generateTests?.({
-          design: params["design"],
-          framework: params["framework"] ?? "vitest"
-        });
-        return ok(tests ?? { files: [], framework: params["framework"] ?? "vitest" });
+        const { createUnitTestGenerator: createUnitTestGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const suite = createUnitTestGenerator2().generate(params["code"] ?? "", params["style"] ?? "unit");
+        return ok(suite);
       } catch {
-        return ok({ files: [], framework: params["framework"] ?? "vitest" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.trace.verify", "Verify full traceability matrix (requirements \u2192 design \u2192 code \u2192 tests)", "sdd-core", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("sdd.trace.verify", "Verify requirement \u2192 code coverage by scanning source references (REQ-XXX-NNN)", "sdd-core", [
+      param("requirementIds", "array", 'Requirement IDs to check (e.g. ["REQ-AUT-001"])'),
+      param("sources", "array", "Sources as {file, code} objects to scan for references")
+    ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.verifyTraceabilityMatrix?.(params["basePath"] ?? ".");
-        return ok(result ?? { complete: true, matrix: [], gaps: [] });
+        const reqIds = [...new Set(params["requirementIds"] ?? [])];
+        const sources = params["sources"] ?? [];
+        const refRe = /REQ-[A-Z]{3}-\d{3}/g;
+        const covered = /* @__PURE__ */ new Set();
+        for (const s of sources) {
+          for (const m of (s.code ?? "").matchAll(refRe)) {
+            if (reqIds.includes(m[0]))
+              covered.add(m[0]);
+          }
+        }
+        const gaps = reqIds.filter((r) => !covered.has(r));
+        const coverage = reqIds.length === 0 ? 0 : Math.round(covered.size / reqIds.length * 100);
+        return ok({
+          total: reqIds.length,
+          covered: covered.size,
+          coverage,
+          gaps,
+          complete: gaps.length === 0 && reqIds.length > 0
+        });
       } catch {
-        return ok({ complete: true, matrix: [], gaps: [] });
+        return fail("Trace verification failed");
       }
     }),
     // ── Requirements Interview tools ──
@@ -14149,63 +14180,101 @@ function policyTools() {
     })
   ];
 }
+async function loadTripleStore(basePath) {
+  const { createOntologyStore: createOntologyStore2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+  const store = createOntologyStore2();
+  const { existsSync: existsSync12, readFileSync: readFileSync7 } = await import("node:fs");
+  const { join: join8 } = await import("node:path");
+  const file = join8(basePath, ".musubix", "ontology.json");
+  try {
+    if (existsSync12(file)) {
+      store.addTriples(JSON.parse(readFileSync7(file, "utf-8")));
+    }
+  } catch {
+  }
+  return { store, file };
+}
+async function saveTripleStore(store, file) {
+  const { writeFileSync: writeFileSync4, mkdirSync: mkdirSync4 } = await import("node:fs");
+  const { dirname: dirname4 } = await import("node:path");
+  mkdirSync4(dirname4(file), { recursive: true });
+  writeFileSync4(file, JSON.stringify(store.getAll(), null, 2), "utf-8");
+}
 function ontologyTools() {
   return [
-    tool("ontology.triple.add", "Add a triple (subject, predicate, object) to the ontology store", "ontology", [
-      param("subject", "string", "Subject URI"),
-      param("predicate", "string", "Predicate URI"),
-      param("object", "string", "Object URI or literal")
+    tool("ontology.triple.add", "Add a triple (subject, predicate, object) to the persisted ontology store", "ontology", [
+      param("subject", "string", "Subject"),
+      param("predicate", "string", "Predicate"),
+      param("object", "string", "Object (URI or literal)"),
+      param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const store = ont.createTripleStore?.();
-        store?.add(params["subject"], params["predicate"], params["object"]);
-        return ok({ added: true, subject: params["subject"], predicate: params["predicate"], object: params["object"] });
+        const { store, file } = await loadTripleStore(params["basePath"] ?? ".");
+        store.addTriple({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        await saveTripleStore(store, file);
+        return ok({ added: true, total: store.size() });
       } catch {
-        return ok({ added: true, subject: params["subject"], predicate: params["predicate"], object: params["object"] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.triple.query", "Query triples by pattern matching", "ontology", [
-      param("subject", "string", "Subject pattern (empty for wildcard)", false),
-      param("predicate", "string", "Predicate pattern (empty for wildcard)", false),
-      param("object", "string", "Object pattern (empty for wildcard)", false)
+    tool("ontology.triple.query", "Query triples by pattern (omit a term to wildcard it)", "ontology", [
+      param("subject", "string", "Subject pattern", false),
+      param("predicate", "string", "Predicate pattern", false),
+      param("object", "string", "Object pattern", false),
+      param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const store = ont.createTripleStore?.();
-        const results = store?.query(params["subject"], params["predicate"], params["object"]);
-        return ok(results ?? []);
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        const results = store.query({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        return ok({ results, count: results.length });
       } catch {
-        return ok([]);
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.rules.apply", "Apply rule engine to infer new triples", "ontology", [param("rules", "array", "Rules to apply", false)], async (params) => {
+    tool("ontology.rules.apply", "Apply the default OWL 2 RL rule engine to infer new triples", "ontology", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const engine = ont.createRuleEngine?.();
-        const result = engine?.apply(params["rules"]);
-        return ok(result ?? { inferred: 0, triples: [] });
+        const { createRuleEngine: createRuleEngine2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+        const { store, file } = await loadTripleStore(params["basePath"] ?? ".");
+        const result = createRuleEngine2(true).applyRules(store);
+        await saveTripleStore(store, file);
+        return ok(result);
       } catch {
-        return ok({ inferred: 0, triples: [] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.consistency.check", "Check ontology consistency", "ontology", [], async () => {
+    tool("ontology.consistency.check", "Check ontology consistency against the persisted store", "ontology", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const checker = ont.createConsistencyChecker?.();
-        const result = checker?.check();
-        return ok(result ?? { consistent: true, issues: [] });
+        const { createConsistencyValidator: createConsistencyValidator2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        return ok(createConsistencyValidator2().validate(store));
       } catch {
-        return ok({ consistent: true, issues: [] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.sparql.query", "Execute a SPARQL-like query against the ontology", "ontology", [param("query", "string", "SPARQL-like query string")], async (params) => {
+    tool("ontology.sparql.query", "Pattern query over the store (basic subject/predicate/object matching)", "ontology", [
+      param("subject", "string", "Subject pattern", false),
+      param("predicate", "string", "Predicate pattern", false),
+      param("object", "string", "Object pattern", false),
+      param("basePath", "string", "Project base path", false, ".")
+    ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const result = ont.sparqlQuery?.(params["query"]);
-        return ok(result ?? { bindings: [] });
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        const bindings = store.query({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        return ok({ bindings, count: bindings.length });
       } catch {
-        return ok({ bindings: [] });
+        return fail("Ontology package not available");
       }
     })
   ];
@@ -14217,47 +14286,78 @@ function codeAnalysisTools() {
       param("language", "string", "Source language: typescript | javascript | python", false, "typescript")
     ], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const ast = cg.parseSource?.(params["source"], params["language"] ?? "typescript");
-        return ok(ast ?? { type: "Program", body: [] });
+        const { createASTParser: createASTParser2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const nodes = createASTParser2().parse(params["source"] ?? "", params["language"] ?? "typescript");
+        return ok({ nodes, count: nodes.length });
       } catch {
-        return ok({ type: "Program", body: [] });
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.graph.build", "Build a dependency graph from source files", "code-analysis", [
-      param("entryPoint", "string", "Entry point file path"),
-      param("basePath", "string", "Project base path", false, ".")
-    ], async (params) => {
+    tool("code.graph.build", "Build a code graph (nodes) from inline sources", "code-analysis", [param("sources", "array", "Sources as {code, language, filePath} objects")], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const graph = cg.buildDependencyGraph?.(params["entryPoint"], params["basePath"] ?? ".");
-        return ok(graph ?? { nodes: [], edges: [] });
+        const { createASTParser: createASTParser2, createGraphEngine: createGraphEngine2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const parser = createASTParser2();
+        const engine = createGraphEngine2();
+        const sources = params["sources"] ?? [];
+        for (const s of sources) {
+          const lang = s.language ?? "typescript";
+          for (const n of parser.parse(s.code ?? "", lang)) {
+            engine.addNode({
+              id: `${s.filePath ?? "inline"}:${n.name}`,
+              name: n.name,
+              kind: n.kind,
+              filePath: s.filePath ?? "inline",
+              language: lang,
+              startLine: n.startLine ?? 0,
+              endLine: n.endLine ?? 0
+            });
+          }
+        }
+        const stats = engine.getStats();
+        return ok({ nodeCount: stats.nodeCount, edgeCount: stats.edgeCount, languages: [...stats.languages] });
       } catch {
-        return ok({ nodes: [], edges: [] });
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.graph.search", "Search code graph using GraphRAG techniques", "code-analysis", [
+    tool("code.graph.search", "Search a code graph built from inline sources using GraphRAG", "code-analysis", [
       param("query", "string", "Search query"),
-      param("basePath", "string", "Project base path", false, ".")
+      param("sources", "array", "Sources as {code, language, filePath} objects to index")
     ], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const results = cg.graphSearch?.(params["query"], params["basePath"] ?? ".");
-        return ok(results ?? []);
+        const { createASTParser: createASTParser2, createGraphEngine: createGraphEngine2, GraphRAGSearch: GraphRAGSearch2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const parser = createASTParser2();
+        const engine = createGraphEngine2();
+        const sources = params["sources"] ?? [];
+        for (const s of sources) {
+          const lang = s.language ?? "typescript";
+          for (const n of parser.parse(s.code ?? "", lang)) {
+            engine.addNode({
+              id: `${s.filePath ?? "inline"}:${n.name}`,
+              name: n.name,
+              kind: n.kind,
+              filePath: s.filePath ?? "inline",
+              language: lang,
+              startLine: n.startLine ?? 0,
+              endLine: n.endLine ?? 0
+            });
+          }
+        }
+        const results = new GraphRAGSearch2(engine).globalSearch(params["query"] ?? "");
+        return ok({ query: params["query"], results });
       } catch {
-        return ok([]);
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.dfg.analyze", "Perform data flow analysis on source code", "code-analysis", [
-      param("source", "string", "Source code to analyze"),
-      param("language", "string", "Source language", false, "typescript")
+    tool("code.dfg.analyze", "Build a data-flow graph from structured statements and report reaching definitions", "code-analysis", [
+      param("statements", "array", "SimpleStatement[] (type/line/variable/value/usedVariables)"),
+      param("scope", "string", "Scope name", false, "global")
     ], async (params) => {
       try {
-        const dfg = await Promise.resolve().then(() => (init_dist13(), dist_exports13));
-        const result = dfg.analyzeDataFlow?.(params["source"], params["language"] ?? "typescript");
-        return ok(result ?? { flows: [], variables: [] });
+        const { createDataFlowAnalyzer: createDataFlowAnalyzer2 } = await Promise.resolve().then(() => (init_dist13(), dist_exports13));
+        const dfg = createDataFlowAnalyzer2().buildDFG(params["statements"] ?? [], params["scope"] ?? "global");
+        return ok(dfg);
       } catch {
-        return ok({ flows: [], variables: [] });
+        return fail("DFG package not available");
       }
     })
   ];
@@ -14424,40 +14524,91 @@ function neuralTools() {
 }
 function synthesisTools() {
   return [
-    tool("synthesis.dsl.build", "Build a DSL transformation from specification", "synthesis", [
-      param("spec", "object", "DSL specification"),
-      param("examples", "array", "Input/output examples", false)
+    tool("synthesis.dsl.build", "Apply a DSL transform pipeline to an input string", "synthesis", [
+      param("input", "string", "Input string to transform"),
+      param("ops", "array", "Ops: trim | upper | lower | reverse | capitalize | camelCase | snakeCase | replace:from:to")
     ], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.buildDSL?.(params["spec"], params["examples"]);
-        return ok(result ?? { dsl: null, spec: params["spec"] });
+        const { createDSLBuilder: createDSLBuilder2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const builder = createDSLBuilder2();
+        const ops = params["ops"] ?? [];
+        for (const op of ops) {
+          const [name, ...a] = String(op).split(":");
+          switch (name) {
+            case "trim":
+              builder.trim();
+              break;
+            case "upper":
+            case "toUpperCase":
+              builder.toUpperCase();
+              break;
+            case "lower":
+            case "toLowerCase":
+              builder.toLowerCase();
+              break;
+            case "reverse":
+              builder.reverse();
+              break;
+            case "capitalize":
+              builder.capitalize();
+              break;
+            case "camelCase":
+            case "camel":
+              builder.camelCase();
+              break;
+            case "snakeCase":
+            case "snake":
+              builder.snakeCase();
+              break;
+            case "replace":
+              builder.replace(a[0] ?? "", a[1] ?? "");
+              break;
+            case "prefixRemove":
+              builder.prefixRemove(a[0] ?? "");
+              break;
+            case "suffixAppend":
+              builder.suffixAppend(a[0] ?? "");
+              break;
+            default:
+              return fail(`Unknown DSL op: ${name}`);
+          }
+        }
+        const result = builder.execute(params["input"] ?? "");
+        return ok({ input: params["input"], ops, result });
       } catch {
-        return ok({ dsl: null, spec: params["spec"] });
+        return fail("Synthesis package not available");
       }
     }),
-    tool("synthesis.synthesize", "Synthesize a program from input/output examples", "synthesis", [
-      param("examples", "array", "Input/output example pairs"),
-      param("constraints", "object", "Synthesis constraints", false)
-    ], async (params) => {
+    tool("synthesis.synthesize", "Synthesize a transformation rule from input/output examples", "synthesis", [param("examples", "array", "Array of {input, output} example pairs")], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.synthesize?.(params["examples"], params["constraints"]);
-        return ok(result ?? { program: null, confidence: 0 });
+        const { createSynthesisEngine: createSynthesisEngine2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const examples = (params["examples"] ?? []).map((e) => ({
+          input: e.input ?? "",
+          output: e.output ?? ""
+        }));
+        const rule = createSynthesisEngine2().synthesize(examples);
+        return ok({ rule, synthesized: rule !== null });
       } catch {
-        return ok({ program: null, confidence: 0 });
+        return fail("Synthesis package not available");
       }
     }),
-    tool("synthesis.version-space", "Manage version spaces for program synthesis", "synthesis", [
-      param("action", "string", "Action: create | update | query"),
-      param("examples", "array", "Examples for version space", false)
+    tool("synthesis.version-space", "Build a version space from positive/negative examples and get consistent hypotheses", "synthesis", [
+      param("name", "string", "Version space name", false, "default"),
+      param("positive", "array", "Positive examples", false),
+      param("negative", "array", "Negative examples", false)
     ], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.versionSpace?.(params["action"], params["examples"]);
-        return ok(result ?? { action: params["action"], spaces: [] });
+        const { createVersionSpaceManager: createVersionSpaceManager2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const mgr = createVersionSpaceManager2();
+        const name = params["name"] ?? "default";
+        mgr.create(name);
+        for (const p of params["positive"] ?? [])
+          mgr.addPositive(name, p);
+        for (const n of params["negative"] ?? [])
+          mgr.addNegative(name, n);
+        return ok({ name, hypotheses: mgr.getConsistentHypotheses(name), spaces: mgr.getSpaces().size });
       } catch {
-        return ok({ action: params["action"], spaces: [] });
+        return fail("Synthesis package not available");
       }
     })
   ];
@@ -14579,37 +14730,41 @@ function decisionsTools() {
       param("consequences", "string", "Consequences of the decision", false)
     ], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const adr = dec.createADR?.({
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        const adr = await mgr.create({
           title: params["title"],
-          context: params["context"],
-          decision: params["decision"],
-          consequences: params["consequences"]
+          context: params["context"] ?? "",
+          decision: params["decision"] ?? "",
+          consequences: params["consequences"] ?? ""
         });
-        return ok(adr ?? { title: params["title"], status: "proposed" });
+        return ok(adr);
       } catch {
-        return ok({ title: params["title"], status: "proposed" });
+        return fail("Decisions package not available");
       }
     }),
-    tool("decisions.list", "List all Architecture Decision Records", "decisions", [param("basePath", "string", "ADR directory path", false, ".")], async (params) => {
+    tool("decisions.list", "List all Architecture Decision Records", "decisions", [param("basePath", "string", "ADR base path", false, ".decisions")], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const adrs = dec.listADRs?.(params["basePath"] ?? ".");
-        return ok(adrs ?? []);
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        return ok(await mgr.list());
       } catch {
-        return ok([]);
+        return fail("Decisions package not available");
       }
     }),
     tool("decisions.search", "Search Architecture Decision Records by keyword", "decisions", [
       param("query", "string", "Search query"),
-      param("basePath", "string", "ADR directory path", false, ".")
+      param("basePath", "string", "ADR base path", false, ".decisions")
     ], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const results = dec.searchADRs?.(params["query"], params["basePath"] ?? ".");
-        return ok(results ?? []);
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        return ok(await mgr.search(params["query"]));
       } catch {
-        return ok([]);
+        return fail("Decisions package not available");
       }
     })
   ];