codetrellis 0.0.0-stage → 0.2.0

package/src/backend/mcp/tools/architecture-tools.js

@@ -0,0 +1,273 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var architecture_tools_exports = {};
+__export(architecture_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(architecture_tools_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_zod = require("zod");
+var import_rules_overview = require("../../services/rules-overview");
+var import_architecture_rules = require("../../services/architecture-rules");
+var import_rule_preview = require("../../services/rule-preview");
+var import_rule_scope = require("../../services/rule-scope");
+var import_rule_proposals = require("../../services/rule-proposals");
+var import_helpers = require("../helpers");
+function register(server, deps) {
+  server.registerTool(
+    "search_symbols",
+    {
+      description: "Search for functions, classes, interfaces, and other symbols across the codebase by name",
+      inputSchema: {
+        query: import_zod.z.string().describe("Symbol name to search for (substring match)")
+      }
+    },
+    async ({ query }) => {
+      const results = deps.searchSymbols(query);
+      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "get_dependencies",
+    {
+      description: "Get what a file imports and what imports it. Returns incoming and outgoing dependency edges.",
+      inputSchema: {
+        file_path: import_zod.z.string().describe("Path to the file: absolute, or relative to the project root")
+      }
+    },
+    async ({ file_path }) => {
+      const result = deps.getFileDependencies(file_path);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "check_architecture",
+    {
+      description: "Query the codebase dependency graph. Returns all file-to-file import edges, showing how the codebase is connected.",
+      inputSchema: {
+        query: import_zod.z.string().optional().describe("Optional: filter edges by file path substring")
+      }
+    },
+    async ({ query }) => {
+      let edges = deps.getDependencyEdges();
+      if (query) {
+        edges = edges.filter(
+          (e) => e.sourceRelative.includes(query) || e.targetRelative.includes(query)
+        );
+      }
+      const stats = deps.getDbStats();
+      return { content: [{ type: "text", text: JSON.stringify({ stats, edges }, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "list_cross_system_edges",
+    {
+      description: "Cross-system edges \u2014 non-import couplings between files inferred from runtime patterns. Today: HTTP fetches in TS/JS matched against FastAPI/Flask routes in Python (more protocols coming: SQL refs, subprocess, env-configured URLs, OpenAPI contracts). Use this to see how the frontend talks to the backend even when no import edges exist.",
+      inputSchema: {}
+    },
+    async () => {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ stats: deps.getCrossSystemStats(), edges: deps.listCrossSystemEdges() }, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "check_conformity",
+    {
+      description: `Check proposed imports before you write them: whether each would cross one of the team's architecture rules ("web/ may not import db/", kept in .codetrellis/rules/<suite>.yaml, with why), or create a direct two-file cycle. suite, rule or path limits it to part of the rulebook. A clean result means no rule is broken and no direct cycle made; list_rules shows the rules.`,
+      inputSchema: {
+        proposed_imports: import_zod.z.array(import_zod.z.object({
+          from: import_zod.z.string().describe("File that would contain the import (absolute, or relative to the project root)"),
+          importing: import_zod.z.string().describe("File being imported (absolute, or relative to the project root)")
+        })).describe("List of proposed import relationships to check"),
+        project_path: import_zod.z.string().optional().describe("An opened project. Omit for the one open in the app."),
+        suite: import_zod.z.string().max(500).optional().describe("Check only these suites' rules (comma-separated, like payments)."),
+        rule: import_zod.z.string().max(500).optional().describe("Check only these rules, by id (comma-separated)."),
+        path: import_zod.z.string().max(500).optional().describe("Check only the rules about these paths (comma-separated).")
+      }
+    },
+    async ({ proposed_imports, project_path, suite, rule: ruleIds, path: scopePath }) => {
+      const root = project_path ?? deps.getActiveProjectPath();
+      const edges = deps.getDependencyEdges();
+      const edgeSet = new Set(edges.map((e) => `${e.sourceRelative}->${e.targetRelative}`));
+      const violations = [];
+      const rel = (p) => {
+        const r = root && import_node_path.default.isAbsolute(p) ? import_node_path.default.relative(root, p) : p;
+        return r.split(import_node_path.default.sep).join("/").replace(/^\.\//, "");
+      };
+      const rules = root ? (0, import_rule_scope.scopeRules)((0, import_architecture_rules.rulesOf)(root), (0, import_rule_scope.parseScope)({ suite, rule: ruleIds, path: scopePath })) : [];
+      for (const imp of proposed_imports) {
+        const from = rel(imp.from);
+        const to = rel(imp.importing);
+        for (const b of (0, import_architecture_rules.checkEdges)(rules, [{ from, to }])) {
+          const rule = rules.find((r) => r.id === b.rule);
+          violations.push({ rule: rule.id, message: (0, import_architecture_rules.breachWords)(rule, b), ...rule.because ? { because: rule.because } : {} });
+        }
+        if (edgeSet.has(`${to}->${from}`)) {
+          violations.push({
+            rule: "circular-dependency",
+            message: `Adding ${imp.from} -> ${imp.importing} would create a circular dependency (${imp.importing} already imports ${imp.from})`
+          });
+        }
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            conformant: violations.length === 0,
+            violations,
+            checkedImports: proposed_imports.length,
+            rules: rules.length
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "list_rules",
+    {
+      description: `The team's architecture rules (Phase 32 A7): path boundaries such as "web/ may not import db/ (except db/types.ts): web talks to db through the API", kept in committed suite files (.codetrellis/rules/<suite>.yaml), each with the imports that break it today. A person sets them in the app; this only reads. Check an import before writing it with check_conformity.`,
+      inputSchema: {
+        project_path: import_zod.z.string().optional().describe("An opened project. Omit for the one open in the app.")
+      }
+    },
+    async ({ project_path }) => {
+      const root = project_path ?? deps.getActiveProjectPath();
+      if (!root) return { isError: true, content: [{ type: "text", text: "No project is open." }] };
+      const view = (0, import_architecture_rules.rulesView)(root, (0, import_architecture_rules.edgesIfLoaded)(root, deps.getActiveProjectPath(), deps.getDependencyEdges));
+      const debt = (0, import_rules_overview.debtByRule)(root);
+      return { content: [{ type: "text", text: JSON.stringify({ rules: view.map((v) => ({ ...v, debt: debt.get(v.rule.id) ?? 0 })) }, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "propose_rule",
+    {
+      description: "Propose a change to one of the team's architecture rules (Phase 33 R3): a new rule, a changed one, or stopping one (remove). Nothing changes: the proposal waits for a person, who sees what it would do against the code and accepts or rejects it in the app. Returns what it would do now, in the words the check uses. You cannot change a rule yourself, and editing .codetrellis/rules/ directly is caught by the check, which judges a branch by its base's rules.",
+      inputSchema: {
+        id: import_zod.z.string().min(1).max(63).describe("The rule's id, a short slug like web-not-db: an existing rule to change or stop, or a new one."),
+        kind: import_zod.z.enum(["imports", "package", "symbol", "calls", "folder", "grep"]).optional().describe("imports (the default): files in from may not import files in may_not_import. package: only the files in only may import the outside package named in package. symbol: only the files in only may import the export named in symbol, directly or through a barrel. calls: only the files in only may make the call named in calls. folder: the files in folder are named to files, of kinds, and export one name each when exports is one. grep: no line of the files in in may hold must_not, or each must hold must."),
+        from: import_zod.z.string().max(300).optional().describe("The files it is about: a folder ending in / or a pattern. Required for an imports rule unless remove; for a package rule, where it applies (everywhere if omitted)."),
+        may_not_import: import_zod.z.string().max(300).optional().describe("What they may not import. Required for an imports rule unless remove."),
+        package: import_zod.z.string().max(300).optional().describe("A package rule's outside package, ecosystem and name: npm:stripe, pypi:requests, go:github.com/stripe/stripe-go, maven:com.stripe."),
+        symbol: import_zod.z.string().max(300).optional().describe("A symbol rule's export, a file and a name: src/payments/charge.ts#createCharge."),
+        calls: import_zod.z.string().max(300).optional().describe("A call rule's call: http: and a host or path (http:api.stripe.com, http:/api/admin), or sql: and a table (sql:payments). A * makes it a glob: http:*.stripe.com, sql:payments_*. Or a kind of the project's own that its .codetrellis/patterns/ find (B4): queue:orders.*, flag:new-checkout."),
+        match: import_zod.z.enum(["exact", "glob", "regex", "fuzzy"]).optional().describe("How a package, symbol or call rule's target is matched (B1): exact (the default), glob (a * in the target says so too), or regex over the whole entry, like http:api\\.(stripe|paypal)\\.com(/.*)?. For a grep rule, how its text is: exact (the default, literal, a * is a *), glob, or regex searched in each line. fuzzy (B3): like it and not it, a look-alike, at or above threshold; then only may be empty (nothing may)."),
+        threshold: import_zod.z.number().gt(0.5).lt(1).optional().describe("For match fuzzy: how alike, 0.85 unless said. A swapped pair in an 8-letter name is 0.88."),
+        in: import_zod.z.array(import_zod.z.string().max(300)).max(50).optional().describe("A grep rule's files, like src/backend/ or src/routes/*.ts."),
+        must_not: import_zod.z.string().max(200).optional().describe("A grep rule's text no line may hold, like console.log(."),
+        must: import_zod.z.string().max(200).optional().describe("A grep rule's text each file must hold on some line, like requireAuth."),
+        ignore_case: import_zod.z.boolean().optional().describe("A grep rule: read its text in any case."),
+        engine: import_zod.z.enum(["deterministic", "fuzzy", "agent"]).optional().describe("Who judges it (B5): deterministic (code, the default), fuzzy (a match: fuzzy target), or agent: words an agent review judges a change by, in rule_words, about the files in in. No code checks an agent rule; it blocks only at block."),
+        rule_words: import_zod.z.string().max(1e3).optional().describe("An agent rule's words: Code that moves money records it through services/ledger, never by writing balances directly."),
+        folder: import_zod.z.string().max(300).optional().describe("A folder rule's folder, like src/backend/services/."),
+        files: import_zod.z.array(import_zod.z.string().max(100)).max(20).optional().describe("A folder rule's name patterns, like *-service.ts."),
+        kinds: import_zod.z.array(import_zod.z.string().max(20)).max(20).optional().describe("A folder rule's file kinds, by extension, like ts."),
+        exports: import_zod.z.enum(["one"]).optional().describe("A folder rule: one, each file exports one name."),
+        guide: import_zod.z.string().max(1e3).optional().describe("A folder rule's judgement half, in prose: shown to people and agents, never checked."),
+        only: import_zod.z.array(import_zod.z.string().max(300)).max(50).optional().describe("A package, symbol or call rule's files that alone may import it or make the call, like src/payments/index.ts."),
+        except: import_zod.z.array(import_zod.z.string().max(300)).max(50).optional().describe("Files they may import all the same."),
+        because: import_zod.z.string().max(200).optional().describe("Why the rule exists, in the team's words."),
+        strength: import_zod.z.enum(["block", "warn", "guide"]).optional().describe("block fails the check; warn is said; guide is never checked. A new rule starts at warn."),
+        suite: import_zod.z.string().max(63).optional().describe("The suite file it belongs in, like payments."),
+        tags: import_zod.z.array(import_zod.z.string().max(32)).max(10).optional().describe("Words a pipeline stage or a check selects it by, like pci (short slugs). Dropping one loosens the rule."),
+        remove: import_zod.z.boolean().optional().describe("Propose stopping the rule."),
+        why: import_zod.z.string().min(1).max(1e3).describe("Why you propose it: what you found, and the evidence."),
+        project_path: import_zod.z.string().optional().describe("An opened project. Omit for the one open in the app.")
+      }
+    },
+    async (args, extra) => {
+      const root = args.project_path ?? deps.getActiveProjectPath();
+      if (!root) return { isError: true, content: [{ type: "text", text: "No project is open." }] };
+      const id = (0, import_helpers.authorFromExtra)(deps, extra);
+      const body = args.remove ? null : {
+        from: args.from,
+        mayNotImport: args.may_not_import,
+        except: args.except,
+        because: args.because,
+        strength: args.strength,
+        suite: args.suite,
+        ...args.kind ? { kind: args.kind } : {},
+        ...args.package ? { package: args.package } : {},
+        ...args.only ? { only: args.only } : {},
+        ...args.symbol ? { symbol: args.symbol } : {},
+        ...args.calls ? { calls: args.calls } : {},
+        ...args.match ? { match: args.match } : {},
+        ...args.threshold !== void 0 ? { threshold: args.threshold } : {},
+        ...args.folder ? { folder: args.folder } : {},
+        ...args.files ? { files: args.files } : {},
+        ...args.kinds ? { kinds: args.kinds } : {},
+        ...args.exports ? { exports: args.exports } : {},
+        ...args.guide ? { guide: args.guide } : {},
+        ...args.in ? { in: args.in } : {},
+        ...args.must_not !== void 0 ? { mustNot: args.must_not } : {},
+        ...args.must !== void 0 ? { must: args.must } : {},
+        ...args.ignore_case !== void 0 ? { ignoreCase: args.ignore_case } : {},
+        ...args.engine ? { engine: args.engine } : {},
+        ...args.rule_words ? { rule: args.rule_words } : {},
+        ...args.tags ? { tags: args.tags } : {}
+      };
+      try {
+        if (!body && !(0, import_architecture_rules.findRule)(root, args.id)) return { isError: true, content: [{ type: "text", text: `No architecture rule "${args.id}" in this project to stop.` }] };
+        const next = body ? (0, import_architecture_rules.proposedRule)(root, { ...body, id: args.id }, id.author).rule : null;
+        const preview = (0, import_rule_preview.previewChange)(root, args.id, next, (0, import_architecture_rules.edgesIfLoaded)(root, deps.getActiveProjectPath(), deps.getDependencyEdges, void 0, next ? [next] : []));
+        if (!preview.change) return { isError: true, content: [{ type: "text", text: `${preview.words} Nothing to propose.` }] };
+        const proposal = (0, import_rule_proposals.addRuleProposal)({
+          projectRoot: root,
+          ruleId: args.id,
+          body,
+          why: args.why,
+          effect: preview.change.effect,
+          words: preview.words,
+          author: id.author,
+          authorType: id.authorType,
+          sessionId: deps.sessionId ?? null
+        });
+        deps.broadcast?.("rules-changed", { project: root });
+        return {
+          _meta: { summary: `Proposed a change to ${args.id}; a person decides` },
+          content: [{ type: "text", text: JSON.stringify({
+            proposal: proposal.uid,
+            status: proposal.status,
+            ...(0, import_rule_preview.previewJson)(preview),
+            next: "A person decides in the app. Until then the rule is as it was; carry on under it."
+          }, null, 2) }]
+        };
+      } catch (err) {
+        if (err instanceof import_architecture_rules.RuleError) return { isError: true, content: [{ type: "text", text: err.message }] };
+        throw err;
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});

package/src/backend/mcp/tools/audio-tools.js

@@ -0,0 +1,117 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var audio_tools_exports = {};
+__export(audio_tools_exports, {
+  registerAudioTools: () => registerAudioTools
+});
+module.exports = __toCommonJS(audio_tools_exports);
+var import_zod = require("zod");
+var import_audio_buffer_service = require("../../services/audio-buffer-service");
+function registerAudioTools(server) {
+  server.tool(
+    "start_audio_capture",
+    "Start capturing audio from the user's microphone. Audio streams into a rolling buffer (default 120 seconds). Use get_audio_context to retrieve the buffered audio.",
+    {
+      max_buffer_seconds: import_zod.z.number().min(1).max(600).optional().describe("Maximum buffer duration in seconds, 1\u2013600 (default: 120)")
+    },
+    async ({ max_buffer_seconds }) => {
+      import_audio_buffer_service.audioBuffer.startCapture(max_buffer_seconds);
+      const status = import_audio_buffer_service.audioBuffer.getStatus();
+      return {
+        content: [{ type: "text", text: JSON.stringify({ message: "Audio capture started", status }) }]
+      };
+    }
+  );
+  server.tool(
+    "stop_audio_capture",
+    "Stop audio capture. The buffer is preserved and can still be read via get_audio_context until the next start.",
+    {},
+    async () => {
+      import_audio_buffer_service.audioBuffer.stopCapture();
+      const status = import_audio_buffer_service.audioBuffer.getStatus();
+      return {
+        content: [{ type: "text", text: JSON.stringify({ message: "Audio capture stopped", status }) }]
+      };
+    }
+  );
+  server.tool(
+    "push_audio_chunk",
+    "Push a chunk of audio data into the capture buffer. Used internally by the frontend \u2014 agents should use get_audio_context to read audio.",
+    {
+      audio_base64: import_zod.z.string().describe("Base64-encoded audio data (WebM/Opus)"),
+      duration_ms: import_zod.z.number().positive().max(6e4).describe("Duration of this chunk in milliseconds (up to 60000)")
+    },
+    async ({ audio_base64, duration_ms }) => {
+      if (!import_audio_buffer_service.audioBuffer.isCapturing()) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Audio capture is not active" }) }],
+          isError: true
+        };
+      }
+      const data = Buffer.from(audio_base64, "base64");
+      import_audio_buffer_service.audioBuffer.addChunk(data, duration_ms);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ accepted: true, status: import_audio_buffer_service.audioBuffer.getStatus() }) }]
+      };
+    }
+  );
+  server.tool(
+    "get_audio_context",
+    "Get the most recent audio from the capture buffer. Returns base64-encoded WebM/Opus audio that multi-modal models can process directly. Use this when the user invokes you during a meeting or discussion \u2014 the audio provides conversation context without transcription.",
+    {
+      seconds: import_zod.z.number().optional().describe(
+        "How many seconds of recent audio to return (default: entire buffer, max: buffer size)"
+      )
+    },
+    async ({ seconds }) => {
+      const snapshot = import_audio_buffer_service.audioBuffer.getRecentAudio(seconds);
+      if (!snapshot) {
+        const status = import_audio_buffer_service.audioBuffer.getStatus();
+        const reason = status.capturing ? "Audio capture is active but the buffer is empty \u2014 no chunks received yet." : "Audio capture is not active. Ask the user to start audio capture first.";
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "No audio available", reason, status }) }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          durationSeconds: snapshot.durationSeconds,
+          mimeType: snapshot.mimeType,
+          startsAt: snapshot.startsAt,
+          endsAt: snapshot.endsAt,
+          chunkCount: snapshot.chunkCount,
+          audioBase64: snapshot.audioBase64
+        }) }]
+      };
+    }
+  );
+  server.tool(
+    "get_audio_status",
+    "Check the audio capture state \u2014 whether capture is active, how much audio is buffered, and when capture started. Use this before get_audio_context to verify audio is available.",
+    {},
+    async () => {
+      const status = import_audio_buffer_service.audioBuffer.getStatus();
+      return {
+        content: [{ type: "text", text: JSON.stringify(status) }]
+      };
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerAudioTools
+});