musubix2 0.5.8 → 0.5.9

package/.claude/.musubix-managed

@@ -1 +1 @@
-{"generator":"musubix2","version":"0.5.8","timestamp":"2026-07-09T10:18:54.616Z"}
+{"generator":"musubix2","version":"0.5.9","timestamp":"2026-07-09T10:34:18.313Z"}

package/dist/assets/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0",
-  "generatedAt": "2026-07-09T10:18:54.648Z",
+  "generatedAt": "2026-07-09T10:34:18.341Z",
   "entries": [
     {
       "platform": "copilot",

package/dist/cli.js

@@ -14180,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");
       }
     })
   ];
@@ -14248,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");
       }
     })
   ];

package/dist/index.js

@@ -14180,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");
       }
     })
   ];
@@ -14248,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");
       }
     })
   ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musubix2",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "description": "MUSUBIX2 — Specification Driven Development System",
   "type": "module",
   "main": "./dist/index.js",