@tritard/waterbrother 0.5.0

package/src/impact.js

@@ -0,0 +1,161 @@
+import path from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+
+function shellEscape(arg) {
+  if (/^[a-zA-Z0-9_./:@%+=,-]+$/.test(arg)) return arg;
+  return `'${String(arg).replace(/'/g, `'"'"'`)}'`;
+}
+
+async function runCommand(command, { cwd, maxBuffer = 1024 * 1024 } = {}) {
+  try {
+    const { stdout, stderr } = await execAsync(command, { cwd, maxBuffer });
+    return { ok: true, stdout: String(stdout || ''), stderr: String(stderr || '') };
+  } catch (error) {
+    return {
+      ok: false,
+      code: typeof error?.code === 'number' ? error.code : null,
+      stdout: String(error?.stdout || ''),
+      stderr: String(error?.stderr || error?.message || error || '')
+    };
+  }
+}
+
+function uniqueStrings(values = []) {
+  const out = [];
+  const seen = new Set();
+  for (const value of values) {
+    const next = String(value || '').trim();
+    if (!next || seen.has(next)) continue;
+    seen.add(next);
+    out.push(next);
+  }
+  return out;
+}
+
+function stemFor(filePath) {
+  const base = path.basename(filePath, path.extname(filePath));
+  return base && base !== 'index' ? base : path.basename(path.dirname(filePath));
+}
+
+function buildTestScore(filePath, changedFiles = []) {
+  let score = 0;
+  const normalized = String(filePath || '').toLowerCase();
+  for (const changed of changedFiles) {
+    const changedLower = String(changed || '').toLowerCase();
+    const changedDir = path.dirname(changedLower);
+    const changedStem = stemFor(changedLower).toLowerCase();
+    if (normalized.includes(changedDir) && changedDir !== '.') score += 5;
+    if (normalized.includes(changedStem)) score += 8;
+    const dirParts = changedDir.split('/').filter(Boolean);
+    for (const part of dirParts.slice(-2)) {
+      if (part && normalized.includes(part)) score += 2;
+    }
+  }
+  return score;
+}
+
+export async function computeImpactMap({ cwd, changedFiles = [], maxRelated = 10, maxTests = 6 } = {}) {
+  const normalizedChanged = uniqueStrings(changedFiles.map((item) => String(item || '').replace(/\\/g, '/')));
+  if (normalizedChanged.length === 0) {
+    return {
+      changedFiles: [],
+      relatedFiles: [],
+      suggestedTests: [],
+      notes: ['No changed files recorded for this turn.']
+    };
+  }
+
+  const relatedScores = new Map();
+  const relatedReasons = new Map();
+
+  for (const changed of normalizedChanged.slice(0, 12)) {
+    const queries = uniqueStrings([
+      stemFor(changed),
+      path.basename(changed),
+      path.basename(changed, path.extname(changed))
+    ]).filter((term) => term.length >= 3);
+
+    for (const term of queries.slice(0, 2)) {
+      const result = await runCommand(
+        `rg -n --no-heading --color never -F ${shellEscape(term)} ${shellEscape(cwd)}`,
+        { cwd, maxBuffer: 2 * 1024 * 1024 }
+      );
+      if (!result.ok && result.code !== 1) continue;
+      const lines = String(result.stdout || '').split(/\r?\n/).filter(Boolean).slice(0, 200);
+      for (const line of lines) {
+        const match = line.match(/^(.*?):\d+:/);
+        if (!match) continue;
+        let candidate = path.relative(cwd, match[1]).replace(/\\/g, '/');
+        if (!candidate || normalizedChanged.includes(candidate) || candidate.startsWith('.waterbrother/')) continue;
+        const score = (relatedScores.get(candidate) || 0) + (candidate.endsWith('.md') ? 1 : 3);
+        relatedScores.set(candidate, score);
+        const reasons = relatedReasons.get(candidate) || new Set();
+        reasons.add(`references ${term}`);
+        relatedReasons.set(candidate, reasons);
+      }
+    }
+  }
+
+  const relatedFiles = [...relatedScores.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, maxRelated)
+    .map(([filePath, score]) => ({
+      path: filePath,
+      score,
+      reasons: [...(relatedReasons.get(filePath) || [])]
+    }));
+
+  const testsResult = await runCommand(
+    `rg --files -g '*test*' -g '*spec*' -g '**/__tests__/**' ${shellEscape(cwd)}`,
+    { cwd, maxBuffer: 2 * 1024 * 1024 }
+  );
+  const testCandidates = uniqueStrings(String(testsResult.stdout || '').split(/\r?\n/))
+    .filter((filePath) => !normalizedChanged.includes(filePath))
+    .map((filePath) => ({
+      path: filePath,
+      score: buildTestScore(filePath, normalizedChanged)
+    }))
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, maxTests)
+    .map((item) => ({
+      path: item.path,
+      score: item.score,
+      reason: 'shares module name or directory with changed files'
+    }));
+
+  const notes = [];
+  if (relatedFiles.length === 0) notes.push('No strong related-file signals found from text references.');
+  if (testCandidates.length === 0) notes.push('No nearby test files matched the changed file names.');
+
+  return {
+    changedFiles: normalizedChanged,
+    relatedFiles,
+    suggestedTests: testCandidates,
+    notes
+  };
+}
+
+export function summarizeImpactMap(impact) {
+  if (!impact || typeof impact !== 'object') return null;
+  const changed = Array.isArray(impact.changedFiles) ? impact.changedFiles.length : 0;
+  const related = Array.isArray(impact.relatedFiles) ? impact.relatedFiles.length : 0;
+  const tests = Array.isArray(impact.suggestedTests) ? impact.suggestedTests.length : 0;
+  const docsImpact = (impact.relatedFiles || []).filter((f) => String(f.path || '').endsWith('.md'));
+  const configImpact = (impact.relatedFiles || []).filter((f) => {
+    const p = String(f.path || '').toLowerCase();
+    return p.endsWith('.json') || p.endsWith('.yaml') || p.endsWith('.yml') || p.endsWith('.toml') || p.includes('config');
+  });
+  return {
+    changed,
+    related,
+    tests,
+    docsFiles: docsImpact.map((f) => f.path),
+    configFiles: configImpact.map((f) => f.path),
+    topRelated: (impact.relatedFiles || []).slice(0, 3).map((f) => f.path),
+    topTests: (impact.suggestedTests || []).slice(0, 3).map((f) => f.path)
+  };
+}

package/src/mcp.js

@@ -0,0 +1,376 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+const CLIENT_INFO = { name: "waterbrother", version: "0.1.0" };
+
+function pretty(data) {
+  return typeof data === "string" ? data : JSON.stringify(data, null, 2);
+}
+
+function clipText(text, maxChars = 4000) {
+  const raw = String(text || "");
+  if (raw.length <= maxChars) return raw;
+  return `${raw.slice(0, maxChars)}\n...[truncated]`;
+}
+
+function sanitizeSegment(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "") || "tool";
+}
+
+function buildWireToolName(serverName, toolName) {
+  return `mcp__${sanitizeSegment(serverName)}__${sanitizeSegment(toolName)}`;
+}
+
+function createAbortError() {
+  const error = new Error("Operation aborted");
+  error.name = "AbortError";
+  error.code = "ABORT_ERR";
+  return error;
+}
+
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw createAbortError();
+}
+
+function normalizeInputSchema(schema) {
+  if (schema && typeof schema === "object") return schema;
+  return { type: "object", properties: {} };
+}
+
+function formatToolResult(result, serverName, toolName) {
+  const content = Array.isArray(result?.content) ? result.content : [];
+  const text = content
+    .map((item) => {
+      if (item?.type === "text") return String(item.text || "");
+      if (item?.type === "image") return "[image]";
+      return item && typeof item === "object" ? JSON.stringify(item) : String(item || "");
+    })
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+
+  return pretty({
+    ok: !result?.isError,
+    server: serverName,
+    tool: toolName,
+    content: text || undefined,
+    structuredContent: result?.structuredContent || undefined
+  });
+}
+
+class StdioMessageParser {
+  constructor(onMessage) {
+    this.onMessage = onMessage;
+    this.buffer = Buffer.alloc(0);
+  }
+
+  push(chunk) {
+    this.buffer = Buffer.concat([this.buffer, Buffer.from(chunk)]);
+    this.drain();
+  }
+
+  drain() {
+    while (this.buffer.length > 0) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) return;
+
+      const headerText = this.buffer.slice(0, headerEnd).toString("utf8");
+      const contentLengthMatch = headerText.match(/content-length:\s*(\d+)/i);
+      if (!contentLengthMatch) {
+        throw new Error("MCP response missing Content-Length");
+      }
+
+      const contentLength = Number(contentLengthMatch[1]);
+      const totalLength = headerEnd + 4 + contentLength;
+      if (this.buffer.length < totalLength) return;
+
+      const body = this.buffer.slice(headerEnd + 4, totalLength).toString("utf8");
+      this.buffer = this.buffer.slice(totalLength);
+      this.onMessage(JSON.parse(body));
+    }
+  }
+}
+
+class StdioMcpClient {
+  constructor(serverName, spec, { cwd }) {
+    this.serverName = serverName;
+    this.spec = spec;
+    this.cwd = cwd;
+    this.child = null;
+    this.initialized = false;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.stderr = "";
+    this.serverInfo = null;
+    this.startPromise = null;
+  }
+
+  async start() {
+    if (this.startPromise) return this.startPromise;
+
+    this.startPromise = new Promise((resolve, reject) => {
+      const command = String(this.spec.command || "").trim();
+      if (!command) {
+        reject(new Error(`MCP server ${this.serverName} is missing a command`));
+        return;
+      }
+
+      const args = Array.isArray(this.spec.args) ? this.spec.args.map((item) => String(item)) : [];
+      const env =
+        this.spec.env && typeof this.spec.env === "object"
+          ? { ...process.env, ...this.spec.env }
+          : process.env;
+
+      const child = spawn(command, args, {
+        cwd: this.spec.cwd || this.cwd,
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+
+      this.child = child;
+      const parser = new StdioMessageParser((message) => this.handleMessage(message));
+
+      child.stdout.on("data", (chunk) => {
+        try {
+          parser.push(chunk);
+        } catch (error) {
+          this.failAll(error);
+        }
+      });
+
+      child.stderr.on("data", (chunk) => {
+        this.stderr = clipText(`${this.stderr}${String(chunk || "")}`, 8000);
+      });
+
+      child.on("error", (error) => {
+        this.failAll(error);
+        reject(error);
+      });
+
+      child.on("exit", (code, signal) => {
+        const error = new Error(`MCP server ${this.serverName} exited (${signal || code || 0})`);
+        this.failAll(error);
+      });
+
+      resolve();
+    });
+
+    return this.startPromise;
+  }
+
+  handleMessage(message) {
+    if (!message || !Object.prototype.hasOwnProperty.call(message, "id")) return;
+    const pending = this.pending.get(message.id);
+    if (!pending) return;
+    this.pending.delete(message.id);
+    clearTimeout(pending.timeoutId);
+
+    if (message.error) {
+      const error = new Error(message.error.message || `MCP request failed: ${pending.method}`);
+      error.code = message.error.code;
+      pending.reject(error);
+      return;
+    }
+
+    pending.resolve(message.result);
+  }
+
+  failAll(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timeoutId);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+
+  sendMessage(message) {
+    if (!this.child?.stdin) {
+      throw new Error(`MCP server ${this.serverName} is not running`);
+    }
+
+    const body = Buffer.from(JSON.stringify(message), "utf8");
+    const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "utf8");
+    this.child.stdin.write(Buffer.concat([header, body]));
+  }
+
+  async request(method, params = {}, { signal, timeoutMs = 30000 } = {}) {
+    await this.start();
+    throwIfAborted(signal);
+
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      const timeoutId = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request timed out: ${this.serverName} ${method}`));
+      }, timeoutMs);
+
+      this.pending.set(id, { method, resolve, reject, timeoutId });
+      try {
+        this.sendMessage({
+          jsonrpc: "2.0",
+          id,
+          method,
+          params
+        });
+      } catch (error) {
+        clearTimeout(timeoutId);
+        this.pending.delete(id);
+        reject(error);
+      }
+    });
+  }
+
+  sendNotification(method, params = {}) {
+    this.sendMessage({
+      jsonrpc: "2.0",
+      method,
+      params
+    });
+  }
+
+  async initialize({ signal } = {}) {
+    if (this.initialized) return;
+    const result = await this.request(
+      "initialize",
+      {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: CLIENT_INFO
+      },
+      { signal, timeoutMs: 30000 }
+    );
+
+    this.initialized = true;
+    this.serverInfo = result?.serverInfo || null;
+    this.sendNotification("notifications/initialized", {});
+  }
+
+  async listTools({ signal } = {}) {
+    await this.initialize({ signal });
+    const result = await this.request("tools/list", {}, { signal, timeoutMs: 30000 });
+    return Array.isArray(result?.tools) ? result.tools : [];
+  }
+
+  async callTool(toolName, args, { signal } = {}) {
+    await this.initialize({ signal });
+    return this.request(
+      "tools/call",
+      {
+        name: toolName,
+        arguments: args && typeof args === "object" ? args : {}
+      },
+      { signal, timeoutMs: 120000 }
+    );
+  }
+}
+
+export class McpManager {
+  constructor({ cwd, servers = {} }) {
+    this.cwd = cwd;
+    this.servers = servers && typeof servers === "object" ? servers : {};
+    this.clients = new Map();
+    this.toolMap = new Map();
+    this.serverStatuses = [];
+    this.initPromise = null;
+  }
+
+  async ensureReady({ signal } = {}) {
+    if (this.initPromise) return this.initPromise;
+
+    this.initPromise = (async () => {
+      const entries = Object.entries(this.servers).filter(([, spec]) => spec && !spec.disabled);
+      const statuses = [];
+
+      for (const [serverName, spec] of entries) {
+        const client = new StdioMcpClient(serverName, spec, { cwd: this.cwd });
+        this.clients.set(serverName, client);
+
+        try {
+          const tools = await client.listTools({ signal });
+          const connectedTools = [];
+
+          for (const tool of tools) {
+            const wireName = buildWireToolName(serverName, tool.name);
+            this.toolMap.set(wireName, {
+              serverName,
+              originalName: tool.name,
+              client,
+              definition: {
+                type: "function",
+                function: {
+                  name: wireName,
+                  description: `MCP ${serverName}: ${tool.description || tool.name}`,
+                  parameters: normalizeInputSchema(tool.inputSchema)
+                }
+              }
+            });
+            connectedTools.push({ name: wireName, originalName: tool.name });
+          }
+
+          statuses.push({
+            name: serverName,
+            ok: true,
+            command: spec.command,
+            toolCount: connectedTools.length,
+            tools: connectedTools,
+            serverInfo: client.serverInfo
+          });
+        } catch (error) {
+          statuses.push({
+            name: serverName,
+            ok: false,
+            command: spec.command,
+            toolCount: 0,
+            error: error instanceof Error ? error.message : String(error),
+            stderr: client.stderr || undefined
+          });
+        }
+      }
+
+      this.serverStatuses = statuses;
+    })();
+
+    return this.initPromise;
+  }
+
+  getToolDefs() {
+    return Array.from(this.toolMap.values(), (entry) => entry.definition);
+  }
+
+  getStatus() {
+    return {
+      configured: Object.entries(this.servers).filter(([, spec]) => spec && !spec.disabled).length,
+      connected: this.serverStatuses.filter((item) => item.ok).length,
+      servers: this.serverStatuses
+    };
+  }
+
+  hasTool(toolName) {
+    return this.toolMap.has(toolName);
+  }
+
+  async executeToolCall(toolName, args, { signal } = {}) {
+    await this.ensureReady({ signal });
+    const entry = this.toolMap.get(toolName);
+    if (!entry) {
+      return pretty({ ok: false, error: `Unknown MCP tool: ${toolName}` });
+    }
+
+    try {
+      const result = await entry.client.callTool(entry.originalName, args, { signal });
+      return formatToolResult(result, entry.serverName, entry.originalName);
+    } catch (error) {
+      return pretty({
+        ok: false,
+        server: entry.serverName,
+        tool: entry.originalName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}

package/src/modes.js

@@ -0,0 +1,84 @@
+export const EXPERIENCE_MODES = ["guide", "standard", "expert", "auditor"];
+export const AUTONOMY_MODES = ["ask", "scoped", "auto"];
+
+const EXPERIENCE_DESCRIPTIONS = {
+  guide: "Explain plans in plain language, surface assumptions, and keep users oriented.",
+  standard: "Be concise but clear. Show the plan briefly and focus on execution.",
+  expert: "Be terse and high-signal. Skip education unless risk or ambiguity makes it necessary.",
+  auditor: "Operate as a read-only reviewer. Inspect, verify, and report risks without mutating the repo."
+};
+
+const AUTONOMY_DESCRIPTIONS = {
+  ask: "Ask before any shell command or repo mutation. Optimize for safety and onboarding.",
+  scoped: "Operate freely inside policy and declared contracts, but ask when risk or scope expands.",
+  auto: "Move quickly inside policy and declared contracts with minimal prompting. High-risk actions still require confirmation."
+};
+
+export function normalizeExperienceMode(value) {
+  const next = String(value || "standard").toLowerCase().trim();
+  if (!EXPERIENCE_MODES.includes(next)) {
+    throw new Error(`Invalid mode: ${value}. Expected one of ${EXPERIENCE_MODES.join(", ")}`);
+  }
+  return next;
+}
+
+export function normalizeAutonomyMode(value) {
+  const next = String(value || "scoped").toLowerCase().trim();
+  if (!AUTONOMY_MODES.includes(next)) {
+    throw new Error(`Invalid autonomy: ${value}. Expected one of ${AUTONOMY_MODES.join(", ")}`);
+  }
+  return next;
+}
+
+export function getExperienceModePrompt(mode) {
+  const normalized = normalizeExperienceMode(mode);
+  return EXPERIENCE_DESCRIPTIONS[normalized];
+}
+
+export function getAutonomyModePrompt(mode) {
+  const normalized = normalizeAutonomyMode(mode);
+  return AUTONOMY_DESCRIPTIONS[normalized];
+}
+
+export function modeDefaults(mode) {
+  const normalized = normalizeExperienceMode(mode);
+  if (normalized === "auditor") {
+    return {
+      agentProfile: "reviewer",
+      toolsEnabled: true,
+      traceMode: "on"
+    };
+  }
+  if (normalized === "guide") {
+    return {
+      agentProfile: "coder",
+      toolsEnabled: true,
+      traceMode: "on"
+    };
+  }
+  if (normalized === "expert") {
+    return {
+      agentProfile: "coder",
+      toolsEnabled: true,
+      traceMode: "on"
+    };
+  }
+  return {
+    agentProfile: "coder",
+    toolsEnabled: true,
+    traceMode: "on"
+  };
+}
+
+export function buildOperatorIdentity({ mode = "standard", autonomy = "scoped", profile = "coder" } = {}) {
+  const normalizedMode = normalizeExperienceMode(mode);
+  const normalizedAutonomy = normalizeAutonomyMode(autonomy);
+  return {
+    mode: normalizedMode,
+    autonomy: normalizedAutonomy,
+    profile: String(profile || "coder"),
+    summary: `${normalizedMode}/${normalizedAutonomy}/${String(profile || "coder")}`,
+    modeDescription: EXPERIENCE_DESCRIPTIONS[normalizedMode],
+    autonomyDescription: AUTONOMY_DESCRIPTIONS[normalizedAutonomy]
+  };
+}