agent-mockingbird 0.0.1

package/apps/server/src/backend/logging/logger.ts

@@ -0,0 +1,64 @@
+type LogLevel = "info" | "warn" | "error";
+
+interface LogFields {
+  [key: string]: unknown;
+}
+
+function normalizeError(error: unknown) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    };
+  }
+  return {
+    message: String(error),
+  };
+}
+
+function writeLog(level: LogLevel, scope: string, message: string, fields?: LogFields) {
+  const payload = {
+    level,
+    scope,
+    message,
+    at: new Date().toISOString(),
+    ...(fields ?? {}),
+  };
+  const line = JSON.stringify(payload);
+  if (level === "error") {
+    console.error(line);
+    return;
+  }
+  if (level === "warn") {
+    console.warn(line);
+    return;
+  }
+  console.log(line);
+}
+
+export function createLogger(scope: string) {
+  return {
+    info(message: string, fields?: LogFields) {
+      writeLog("info", scope, message, fields);
+    },
+    warn(message: string, fields?: LogFields) {
+      writeLog("warn", scope, message, fields);
+    },
+    error(message: string, fields?: LogFields) {
+      writeLog("error", scope, message, fields);
+    },
+    errorWithCause(message: string, error: unknown, fields?: LogFields) {
+      writeLog("error", scope, message, {
+        ...(fields ?? {}),
+        error: normalizeError(error),
+      });
+    },
+    warnWithCause(message: string, error: unknown, fields?: LogFields) {
+      writeLog("warn", scope, message, {
+        ...(fields ?? {}),
+        error: normalizeError(error),
+      });
+    },
+  };
+}

package/apps/server/src/backend/mcp/service.ts

@@ -0,0 +1,326 @@
+import type { Config } from "@opencode-ai/sdk/client";
+import { parse as parseJsonc } from "jsonc-parser";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+import type {
+  AgentMockingbirdConfig,
+  ConfiguredMcpServer,
+} from "../config/schema";
+import {
+  createOpencodeClientFromConnection,
+  createOpencodeV2ClientFromConnection,
+  unwrapSdkData,
+} from "../opencode/client";
+import { resolveOpencodeConfigDir } from "../workspace/resolve";
+
+type RuntimeMcpStatus =
+  | "connected"
+  | "disabled"
+  | "failed"
+  | "needs_auth"
+  | "needs_client_registration"
+  | "unknown";
+
+interface RuntimeMcp {
+  id: string;
+  enabled: boolean;
+  status: RuntimeMcpStatus;
+  error?: string;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function stableSerialize(value: unknown): string {
+  if (value === null) return "null";
+  if (
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  ) {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+  }
+  if (!isPlainObject(value)) return JSON.stringify(value);
+  const entries = Object.entries(value).sort(([left], [right]) =>
+    left.localeCompare(right),
+  );
+  return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableSerialize(entry)}`).join(",")}}`;
+}
+
+function hashConfiguredMcpServers(servers: Array<ConfiguredMcpServer>) {
+  return createHash("sha256").update(stableSerialize(servers)).digest("hex");
+}
+
+function createMcpClient(config: AgentMockingbirdConfig) {
+  return createOpencodeV2ClientFromConnection({
+    baseUrl: config.runtime.opencode.baseUrl,
+    directory: config.workspace.pinnedDirectory,
+  });
+}
+
+function createConfigClient(config: AgentMockingbirdConfig) {
+  return createOpencodeClientFromConnection({
+    baseUrl: config.runtime.opencode.baseUrl,
+    directory: config.workspace.pinnedDirectory,
+  });
+}
+
+function normalizeRecordStringMap(value: unknown): Record<string, string> {
+  if (!isPlainObject(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(
+        (entry): entry is [string, string] => typeof entry[1] === "string",
+      )
+      .map(([key, entry]) => [key, entry]),
+  );
+}
+
+function fromOpencodeMcp(
+  id: string,
+  value: unknown,
+): ConfiguredMcpServer | null {
+  if (!isPlainObject(value)) return null;
+  const enabled = value.enabled !== false;
+  if (value.type === "remote" && typeof value.url === "string") {
+    return {
+      id,
+      type: "remote",
+      enabled,
+      url: value.url,
+      headers: normalizeRecordStringMap(value.headers),
+      oauth: value.oauth === false ? "off" : "auto",
+      timeoutMs: typeof value.timeout === "number" ? value.timeout : undefined,
+    };
+  }
+  if (value.type === "local" && Array.isArray(value.command)) {
+    return {
+      id,
+      type: "local",
+      enabled,
+      command: value.command.filter(
+        (entry): entry is string =>
+          typeof entry === "string" && entry.trim().length > 0,
+      ),
+      environment: normalizeRecordStringMap(value.environment),
+      timeoutMs: typeof value.timeout === "number" ? value.timeout : undefined,
+    };
+  }
+  return null;
+}
+
+function toOpencodeMcp(server: ConfiguredMcpServer): Record<string, unknown> {
+  if (server.type === "remote") {
+    return {
+      type: "remote",
+      enabled: server.enabled,
+      url: server.url,
+      headers: server.headers,
+      ...(server.oauth === "off" ? { oauth: false } : {}),
+      ...(typeof server.timeoutMs === "number"
+        ? { timeout: server.timeoutMs }
+        : {}),
+    };
+  }
+  return {
+    type: "local",
+    enabled: server.enabled,
+    command: server.command,
+    environment: server.environment,
+    ...(typeof server.timeoutMs === "number"
+      ? { timeout: server.timeoutMs }
+      : {}),
+  };
+}
+
+function normalizeMcpStatus(value: unknown): RuntimeMcpStatus {
+  if (value === "connected") return value;
+  if (value === "disabled") return value;
+  if (value === "failed") return value;
+  if (value === "needs_auth") return value;
+  if (value === "needs_client_registration") return value;
+  return "unknown";
+}
+
+function extractMcpError(value: unknown) {
+  if (!isPlainObject(value)) return undefined;
+  const error = value.error;
+  if (typeof error !== "string") return undefined;
+  const trimmed = error.trim();
+  return trimmed || undefined;
+}
+
+function opencodeConfigFilePath(config: AgentMockingbirdConfig) {
+  return path.join(resolveOpencodeConfigDir(config), "opencode.jsonc");
+}
+
+export function readConfiguredMcpServersFromWorkspaceConfig(
+  config: AgentMockingbirdConfig,
+): Array<ConfiguredMcpServer> {
+  try {
+    const raw = readFileSync(opencodeConfigFilePath(config), "utf8");
+    const parsed = parseJsonc(raw);
+    if (!isPlainObject(parsed) || !isPlainObject(parsed.mcp)) return [];
+    return Object.entries(parsed.mcp)
+      .map(([id, value]) => fromOpencodeMcp(id.trim(), value))
+      .filter((server): server is ConfiguredMcpServer => Boolean(server))
+      .sort((left, right) => left.id.localeCompare(right.id));
+  } catch {
+    return [];
+  }
+}
+
+export function normalizeMcpIds(ids: Array<string>) {
+  const normalized = ids.map((id) => id.trim()).filter(Boolean);
+  return [...new Set(normalized)].sort((a, b) => a.localeCompare(b));
+}
+
+export function normalizeMcpServerDefinitions(
+  servers: Array<ConfiguredMcpServer>,
+) {
+  const deduped = new Map<string, ConfiguredMcpServer>();
+  for (const server of servers) {
+    const parsed = fromOpencodeMcp(server.id, toOpencodeMcp(server));
+    if (!parsed) continue;
+    deduped.set(parsed.id, parsed);
+  }
+  return [...deduped.values()].sort((left, right) =>
+    left.id.localeCompare(right.id),
+  );
+}
+
+export function resolveConfiguredMcpServers(config: AgentMockingbirdConfig) {
+  return normalizeMcpServerDefinitions(
+    readConfiguredMcpServersFromWorkspaceConfig(config),
+  );
+}
+
+export function resolveConfiguredMcpIds(config: AgentMockingbirdConfig) {
+  return normalizeMcpIds(
+    resolveConfiguredMcpServers(config)
+      .filter((server) => server.enabled)
+      .map((server) => server.id),
+  );
+}
+
+async function getWorkspaceMcpConfig(config: AgentMockingbirdConfig) {
+  const current = unwrapSdkData<Config>(
+    await createConfigClient(config).config.get({
+      responseStyle: "data",
+      throwOnError: true,
+      signal: AbortSignal.timeout(config.runtime.opencode.timeoutMs),
+    }),
+  );
+  const servers = readConfiguredMcpServersFromWorkspaceConfig(config);
+  return {
+    config: current,
+    servers,
+    hash: hashConfiguredMcpServers(servers),
+  };
+}
+
+export async function listRuntimeMcps(
+  config: AgentMockingbirdConfig,
+): Promise<RuntimeMcp[]> {
+  const { servers } = await getWorkspaceMcpConfig(config);
+  const enabled = new Set(
+    servers.filter((server) => server.enabled).map((server) => server.id),
+  );
+  const payload = unwrapSdkData<Record<string, unknown>>(
+    await createMcpClient(config).mcp.status(undefined, {
+      responseStyle: "data",
+      throwOnError: true,
+      signal: AbortSignal.timeout(config.runtime.opencode.timeoutMs),
+    }),
+  );
+
+  const discoveredIds = Object.keys(isPlainObject(payload) ? payload : {})
+    .map((id) => id.trim())
+    .filter(Boolean);
+  const configuredIds = servers.map((server) => server.id);
+  const allIds = new Set([...configuredIds, ...discoveredIds]);
+
+  return [...allIds]
+    .sort((a, b) => a.localeCompare(b))
+    .map((id) => {
+      const rawStatus = isPlainObject(payload) ? payload[id] : undefined;
+      const statusRecord = isPlainObject(rawStatus) ? rawStatus : {};
+      return {
+        id,
+        enabled: enabled.has(id),
+        status: normalizeMcpStatus(statusRecord.status),
+        error: extractMcpError(statusRecord),
+      } satisfies RuntimeMcp;
+    });
+}
+
+export async function connectRuntimeMcp(
+  config: AgentMockingbirdConfig,
+  id: string,
+) {
+  return unwrapSdkData<boolean>(
+    await createMcpClient(config).mcp.connect(
+      { name: id },
+      {
+        responseStyle: "data",
+        throwOnError: true,
+        signal: AbortSignal.timeout(config.runtime.opencode.timeoutMs),
+      },
+    ),
+  );
+}
+
+export async function disconnectRuntimeMcp(
+  config: AgentMockingbirdConfig,
+  id: string,
+) {
+  return unwrapSdkData<boolean>(
+    await createMcpClient(config).mcp.disconnect(
+      { name: id },
+      {
+        responseStyle: "data",
+        throwOnError: true,
+        signal: AbortSignal.timeout(config.runtime.opencode.timeoutMs),
+      },
+    ),
+  );
+}
+
+export async function startRuntimeMcpAuth(
+  config: AgentMockingbirdConfig,
+  id: string,
+) {
+  const response = unwrapSdkData<{ authorizationUrl: string }>(
+    await createMcpClient(config).mcp.auth.start(
+      { name: id },
+      {
+        responseStyle: "data",
+        throwOnError: true,
+        signal: AbortSignal.timeout(config.runtime.opencode.timeoutMs),
+      },
+    ),
+  );
+  return response.authorizationUrl;
+}
+
+export async function removeRuntimeMcpAuth(
+  config: AgentMockingbirdConfig,
+  id: string,
+) {
+  return unwrapSdkData<{ success: true }>(
+    await createMcpClient(config).mcp.auth.remove(
+      { name: id },
+      {
+        responseStyle: "data",
+        throwOnError: true,
+        signal: AbortSignal.timeout(config.runtime.opencode.timeoutMs),
+      },
+    ),
+  );
+}

package/apps/server/src/backend/memory/cli.ts

@@ -0,0 +1,170 @@
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { migrateLegacyMemoryMarkdownToV2 } from "./records";
+import {
+  getMemoryStatus,
+  lintMemory,
+  listMemoryWriteEvents,
+  rememberMemory,
+  searchMemoryDetailed,
+  searchMemory,
+  syncMemoryIndex,
+} from "./service";
+
+function usage() {
+  console.log("Usage:");
+  console.log("  bun run src/backend/memory/cli.ts status");
+  console.log("  bun run src/backend/memory/cli.ts sync");
+  console.log("  bun run src/backend/memory/cli.ts reindex");
+  console.log("  bun run src/backend/memory/cli.ts search <query>");
+  console.log("  bun run src/backend/memory/cli.ts search --debug <query>");
+  console.log("  bun run src/backend/memory/cli.ts remember <content>");
+  console.log("  bun run src/backend/memory/cli.ts activity [limit]");
+  console.log("  bun run src/backend/memory/cli.ts lint");
+  console.log("  bun run src/backend/memory/cli.ts migrate-format");
+}
+
+async function listMarkdownFiles(dir: string, output: string[]) {
+  let entries: Array<{ name: string; isFile: () => boolean; isDirectory: () => boolean }> = [];
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await listMarkdownFiles(fullPath, output);
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      output.push(fullPath);
+    }
+  }
+}
+
+async function collectWorkspaceMemoryFiles(workspaceDir: string) {
+  const files: string[] = [];
+  for (const candidate of [path.join(workspaceDir, "MEMORY.md"), path.join(workspaceDir, "memory.md")]) {
+    try {
+      const fileStat = await stat(candidate);
+      if (fileStat.isFile()) files.push(candidate);
+    } catch {
+      // noop
+    }
+  }
+  await listMarkdownFiles(path.join(workspaceDir, "memory"), files);
+  return [...new Set(files)];
+}
+
+async function run() {
+  const [command, ...args] = process.argv.slice(2);
+  if (!command) {
+    usage();
+    process.exitCode = 1;
+    return;
+  }
+
+  switch (command) {
+    case "status": {
+      const status = await getMemoryStatus();
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    case "sync": {
+      await syncMemoryIndex();
+      const status = await getMemoryStatus();
+      console.log(`Memory sync complete. Files=${status.files} Chunks=${status.chunks}`);
+      return;
+    }
+    case "reindex": {
+      await syncMemoryIndex({ force: true });
+      const status = await getMemoryStatus();
+      console.log(`Memory reindex complete. Files=${status.files} Chunks=${status.chunks}`);
+      return;
+    }
+    case "search": {
+      const debug = args.includes("--debug");
+      const normalizedArgs = args.filter(arg => arg !== "--debug");
+      const query = normalizedArgs.join(" ").trim();
+      if (!query) {
+        console.error("search requires a query");
+        process.exitCode = 1;
+        return;
+      }
+      if (debug) {
+        const detailed = await searchMemoryDetailed(query);
+        console.log(JSON.stringify({ query, results: detailed.results, debug: detailed.debug }, null, 2));
+        return;
+      }
+      const results = await searchMemory(query);
+      console.log(JSON.stringify({ query, results }, null, 2));
+      return;
+    }
+    case "remember": {
+      const content = args.join(" ").trim();
+      if (!content) {
+        console.error("remember requires <content>");
+        process.exitCode = 1;
+        return;
+      }
+      const result = await rememberMemory({
+        source: "system",
+        content,
+      });
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    case "activity": {
+      const rawLimit = Number(args[0] ?? "20");
+      const limit = Number.isFinite(rawLimit) ? rawLimit : 20;
+      const events = await listMemoryWriteEvents(limit);
+      console.log(JSON.stringify({ count: events.length, events }, null, 2));
+      return;
+    }
+    case "lint": {
+      const report = await lintMemory();
+      console.log(JSON.stringify(report, null, 2));
+      process.exitCode = report.ok ? 0 : 2;
+      return;
+    }
+    case "migrate-format": {
+      const status = await getMemoryStatus();
+      const files = await collectWorkspaceMemoryFiles(status.workspaceDir);
+      let migratedFiles = 0;
+      let migratedRecords = 0;
+
+      for (const filePath of files) {
+        const raw = await readFile(filePath, "utf8");
+        const migrated = migrateLegacyMemoryMarkdownToV2(raw);
+        if (migrated.migrated <= 0) continue;
+        await writeFile(filePath, migrated.content, "utf8");
+        migratedFiles += 1;
+        migratedRecords += migrated.migrated;
+      }
+
+      await syncMemoryIndex({ force: true });
+      console.log(
+        JSON.stringify(
+          {
+            ok: true,
+            workspaceDir: status.workspaceDir,
+            filesScanned: files.length,
+            migratedFiles,
+            migratedRecords,
+          },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    default:
+      console.error(`Unknown command: ${command}`);
+      usage();
+      process.exitCode = 1;
+  }
+}
+
+void run();

package/apps/server/src/backend/memory/conceptExpansion.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildConceptExpandedQueries } from "./conceptExpansion";
+
+describe("buildConceptExpandedQueries", () => {
+  test("expands portfolio query to adjacent asset classes", () => {
+    const expanded = buildConceptExpandedQueries("How is my portfolio doing?", {
+      enabled: true,
+      maxPacks: 3,
+      maxTerms: 12,
+    });
+    expect(expanded.matchedConceptPacks).toContain("portfolio");
+    expect(expanded.expandedTokens).toContain("silver");
+    expect(expanded.expandedQueries.some(item => item.type === "lex")).toBe(true);
+    expect(expanded.expandedQueries.some(item => item.type === "vec")).toBe(true);
+  });
+
+  test("respects disable flag", () => {
+    const expanded = buildConceptExpandedQueries("portfolio", {
+      enabled: false,
+      maxPacks: 3,
+      maxTerms: 12,
+    });
+    expect(expanded.matchedConceptPacks).toHaveLength(0);
+    expect(expanded.expandedTokens).toHaveLength(0);
+    expect(expanded.expandedQueries).toHaveLength(0);
+  });
+});

package/apps/server/src/backend/memory/conceptExpansion.ts

@@ -0,0 +1,80 @@
+import { type ExpandedQuery } from "./qmdPort";
+
+const TOKEN_RE = /[a-z0-9]{3,}/g;
+
+interface ConceptPack {
+  name: string;
+  triggers: string[];
+  lex: string;
+}
+
+const CONCEPT_PACKS: ConceptPack[] = [
+  {
+    name: "family",
+    triggers: ["family", "relative", "relatives", "spouse", "daughter", "child", "children", "wife", "husband"],
+    lex: "spouse wife husband partner daughter son child children parent parents mother father siblings sister brother",
+  },
+  {
+    name: "portfolio",
+    triggers: ["portfolio", "investing", "investment", "allocation", "holdings", "assets", "networth", "net-worth"],
+    lex: "stocks etf etfs bonds treasuries commodities metals gold silver crypto bitcoin cash real estate allocation",
+  },
+  {
+    name: "career",
+    triggers: ["career", "job", "work", "company", "employer", "role", "promotion", "manager", "team"],
+    lex: "job role company employer manager team promotion compensation salary bonus",
+  },
+];
+
+function collectTokens(text: string) {
+  const matched = text.toLowerCase().match(TOKEN_RE) ?? [];
+  return new Set(matched);
+}
+
+export function buildConceptExpandedQueries(
+  query: string,
+  options: { enabled: boolean; maxPacks: number; maxTerms: number },
+): {
+  expandedQueries: ExpandedQuery[];
+  expandedTokens: string[];
+  matchedConceptPacks: string[];
+} {
+  if (!options.enabled) {
+    return {
+      expandedQueries: [],
+      expandedTokens: [],
+      matchedConceptPacks: [],
+    };
+  }
+
+  const queryTokens = collectTokens(query);
+  const matched = CONCEPT_PACKS.filter(pack => pack.triggers.some(trigger => queryTokens.has(trigger))).slice(
+    0,
+    Math.max(0, options.maxPacks),
+  );
+
+  const expandedQueries: ExpandedQuery[] = [];
+  const expandedTokens = new Set<string>();
+  const matchedConceptPacks = matched.map(pack => pack.name);
+
+  for (const pack of matched) {
+    expandedQueries.push({ type: "lex", text: pack.lex });
+    expandedQueries.push({ type: "vec", text: `${query} ${pack.lex}`.trim() });
+    for (const token of collectTokens(pack.lex)) {
+      expandedTokens.add(token);
+      if (expandedTokens.size >= Math.max(1, options.maxTerms)) break;
+    }
+    if (expandedTokens.size >= Math.max(1, options.maxTerms)) break;
+  }
+
+  const hyde = `Information about ${query}`.trim();
+  if (hyde.length > "Information about".length) {
+    expandedQueries.push({ type: "hyde", text: hyde });
+  }
+
+  return {
+    expandedQueries,
+    expandedTokens: [...expandedTokens],
+    matchedConceptPacks,
+  };
+}