lynkr 9.9.1 → 9.10.0

package/src/tests/store.js

@@ -1,213 +0,0 @@
-const db = require("../db");
-const logger = require("../logger");
-
-const OUTPUT_SNIPPET_LIMIT = 2000;
-
-const insertTestRunStmt = db.prepare(
-  `INSERT INTO test_runs (
-     profile,
-     status,
-     command,
-     args,
-     cwd,
-     exit_code,
-     timed_out,
-     duration_ms,
-     sandbox,
-     stdout,
-     stderr,
-     coverage,
-     created_at
-   ) VALUES (
-     @profile,
-     @status,
-     @command,
-     @args,
-     @cwd,
-     @exit_code,
-     @timed_out,
-     @duration_ms,
-     @sandbox,
-     @stdout,
-     @stderr,
-     @coverage,
-     @created_at
-   )`,
-);
-
-const listRecentTestRunsStmt = db.prepare(
-  `SELECT
-     id,
-     profile,
-     status,
-     command,
-     args,
-     cwd,
-     exit_code,
-     timed_out,
-     duration_ms,
-     sandbox,
-     stdout,
-     stderr,
-     coverage,
-     created_at
-   FROM test_runs
-   ORDER BY created_at DESC
-   LIMIT ?`,
-);
-
-const countAllTestRunsStmt = db.prepare(`SELECT COUNT(1) AS total FROM test_runs`);
-const countPassedTestRunsStmt = db.prepare(
-  `SELECT COUNT(1) AS total FROM test_runs WHERE status = 'passed'`,
-);
-const selectLatestTestRunStmt = db.prepare(
-  `SELECT
-     id,
-     profile,
-     status,
-     command,
-     args,
-     cwd,
-     exit_code,
-     timed_out,
-     duration_ms,
-     sandbox,
-     stdout,
-     stderr,
-     coverage,
-     created_at
-   FROM test_runs
-   ORDER BY created_at DESC
-   LIMIT 1`,
-);
-
-function truncateOutput(output, limit = OUTPUT_SNIPPET_LIMIT) {
-  if (typeof output !== "string" || output.length === 0) {
-    return { text: output ?? "", truncated: false };
-  }
-  if (output.length <= limit) {
-    return { text: output, truncated: false };
-  }
-  return {
-    text: output.slice(output.length - limit),
-    truncated: true,
-  };
-}
-
-function parseJson(value, fallback = null) {
-  if (typeof value !== "string" || value.length === 0) return fallback;
-  try {
-    return JSON.parse(value);
-  } catch (err) {
-    logger.debug({ err }, "Failed to parse JSON payload in test_runs");
-    return fallback;
-  }
-}
-
-function normaliseArgs(value) {
-  const parsed = parseJson(value, []);
-  if (!Array.isArray(parsed)) return [];
-  return parsed.map((item) => String(item));
-}
-
-function normaliseCoverage(value) {
-  const parsed = parseJson(value, null);
-  if (!parsed || typeof parsed !== "object") return null;
-  return parsed;
-}
-
-function normaliseTestRunRow(row, { includeLogs = false } = {}) {
-  if (!row) return null;
-  const stdoutResult = includeLogs ? { text: row.stdout ?? "", truncated: false } : truncateOutput(row.stdout);
-  const stderrResult = includeLogs ? { text: row.stderr ?? "", truncated: false } : truncateOutput(row.stderr);
-  return {
-    id: row.id,
-    profile: row.profile ?? null,
-    status: row.status ?? null,
-    command: row.command ?? null,
-    args: normaliseArgs(row.args),
-    cwd: row.cwd ?? null,
-    exitCode: typeof row.exit_code === "number" ? row.exit_code : null,
-    timedOut: row.timed_out === 1,
-    durationMs: typeof row.duration_ms === "number" ? row.duration_ms : null,
-    sandbox: row.sandbox ?? null,
-    stdout: stdoutResult.text ?? "",
-    stdoutTruncated: stdoutResult.truncated,
-    stderr: stderrResult.text ?? "",
-    stderrTruncated: stderrResult.truncated,
-    coverage: normaliseCoverage(row.coverage),
-    createdAt: new Date(Number(row.created_at ?? Date.now())).toISOString(),
-  };
-}
-
-function createTestRun({
-  profile,
-  status,
-  command,
-  args,
-  cwd,
-  exitCode,
-  timedOut,
-  durationMs,
-  sandbox,
-  stdout,
-  stderr,
-  coverage,
-  createdAt,
-}) {
-  const payload = {
-    profile: profile ?? null,
-    status: status ?? null,
-    command: command ?? "",
-    args: Array.isArray(args) && args.length ? JSON.stringify(args.map(String)) : null,
-    cwd: cwd ?? null,
-    exit_code: typeof exitCode === "number" ? exitCode : null,
-    timed_out: timedOut ? 1 : 0,
-    duration_ms: typeof durationMs === "number" ? durationMs : null,
-    sandbox: sandbox ?? null,
-    stdout: typeof stdout === "string" ? stdout : stdout ?? "",
-    stderr: typeof stderr === "string" ? stderr : stderr ?? "",
-    coverage: coverage ? JSON.stringify(coverage) : null,
-    created_at: Number.isFinite(createdAt) ? Math.trunc(createdAt) : Date.now(),
-  };
-  const info = insertTestRunStmt.run(payload);
-  return normaliseTestRunRow(
-    {
-      id: info.lastInsertRowid,
-      ...payload,
-    },
-    { includeLogs: true },
-  );
-}
-
-function listTestRuns({ limit = 5, includeLogs = false } = {}) {
-  const clamped = Math.min(Math.max(Number(limit) || 5, 1), 50);
-  const rows = listRecentTestRunsStmt.all(clamped);
-  return rows.map((row) => normaliseTestRunRow(row, { includeLogs }));
-}
-
-function getTestSummary({ includeRecent = false, recentLimit = 5 } = {}) {
-  const totals = countAllTestRunsStmt.get();
-  const passed = countPassedTestRunsStmt.get();
-  const latest = selectLatestTestRunStmt.get();
-  const totalRuns = Number(totals?.total ?? 0);
-  const passedRuns = Number(passed?.total ?? 0);
-  const summary = {
-    totalRuns,
-    passRate: totalRuns > 0 ? Number(((passedRuns / totalRuns) * 100).toFixed(2)) : null,
-    lastRun: latest ? normaliseTestRunRow(latest, { includeLogs: false }) : null,
-  };
-  if (includeRecent) {
-    summary.recentRuns = listTestRuns({
-      limit: recentLimit,
-      includeLogs: false,
-    });
-  }
-  return summary;
-}
-
-module.exports = {
-  createTestRun,
-  listTestRuns,
-  getTestSummary,
-};

package/src/tools/agent-task.js

@@ -1,145 +0,0 @@
-const { registerTool } = require(".");
-const { spawnAgent, autoSelectAgent } = require("../agents");
-const logger = require("../logger");
-
-/**
- * Extract text from Anthropic content blocks format
- * Handles: [{"type":"text","text":"..."}] -> "..."
- */
-function extractTextFromContentBlocks(content) {
-  if (typeof content !== 'string') {
-    return content;
-  }
-
-  const trimmed = content.trim();
-  if (!trimmed.startsWith('[')) {
-    return content;
-  }
-
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (!Array.isArray(parsed)) {
-      return content;
-    }
-
-    // Extract text from content blocks
-    const textParts = parsed
-      .filter(block => block && typeof block === 'object')
-      .map(block => {
-        if (block.type === 'text' && typeof block.text === 'string') {
-          return block.text;
-        }
-        if (typeof block.text === 'string') {
-          return block.text;
-        }
-        return null;
-      })
-      .filter(text => text !== null);
-
-    if (textParts.length > 0) {
-      return textParts.join('\n\n');
-    }
-
-    return content;
-  } catch {
-    return content;
-  }
-}
-
-function registerAgentTaskTool() {
-  registerTool(
-    "Task",
-    async ({ args = {} }, context = {}) => {
-      let subagentType = args.subagent_type || args.type;
-      const prompt = args.prompt;
-      const description = args.description || "Agent task";
-
-      if (!prompt) {
-        return {
-          ok: false,
-          status: 400,
-          content: JSON.stringify({
-            error: "prompt is required"
-          }, null, 2)
-        };
-      }
-
-      // Auto-select agent if not specified
-      if (!subagentType) {
-        const selected = autoSelectAgent(prompt);
-        if (selected) {
-          subagentType = selected.name;
-          logger.info({
-            selectedAgent: subagentType,
-            prompt: prompt.slice(0, 50)
-          }, "Auto-selected subagent");
-        } else {
-          subagentType = "Explore"; // Default fallback
-        }
-      }
-
-      logger.info({
-        subagentType,
-        prompt: prompt.slice(0, 100),
-        sessionId: context.sessionId,
-        cwd: context.cwd
-      }, "Task tool: spawning subagent");
-
-      try {
-        const result = await spawnAgent(subagentType, prompt, {
-          sessionId: context.sessionId,
-          cwd: context.cwd, // Pass client CWD to subagent
-          mainContext: context.mainContext // Pass minimal context
-        });
-
-        if (result.success) {
-          // Extract text from Anthropic content blocks if present
-          const cleanContent = extractTextFromContentBlocks(result.result);
-
-          return {
-            ok: true,
-            status: 200,
-            content: cleanContent,
-            metadata: {
-              agentType: subagentType,
-              agentId: result.stats.agentId,
-              steps: result.stats.steps,
-              durationMs: result.stats.durationMs
-            }
-          };
-        } else {
-          return {
-            ok: false,
-            status: 500,
-            content: JSON.stringify({
-              error: "Subagent execution failed",
-              message: result.error
-            }, null, 2)
-          };
-        }
-
-      } catch (error) {
-        logger.error({
-          error: error.message,
-          subagentType
-        }, "Task tool: subagent error");
-
-        return {
-          ok: false,
-          status: 500,
-          content: JSON.stringify({
-            error: "Subagent error",
-            message: error.message
-          }, null, 2)
-        };
-      }
-    },
-    { category: "agents" }
-  );
-
-  logger.info("Task tool registered");
-}
-
-module.exports = {
-  registerAgentTaskTool
-};

package/src/tools/code-mode.js

@@ -1,304 +0,0 @@
-/**
- * Code Mode — Meta-Tools for MCP Token Optimization
- *
- * Replaces 100+ individual MCP tool definitions with 4 meta-tools,
- * reducing tool-catalog token overhead from ~17,500 to ~700 tokens.
- *
- * Inspired by Bifrost's Code Mode. Instead of sending every MCP tool
- * schema in every request, the LLM discovers tools lazily:
- *   1. mcp_list_tools   → discover available tools (compact)
- *   2. mcp_tool_info    → load full schema for one tool
- *   3. mcp_tool_docs    → get usage examples
- *   4. mcp_execute      → execute a tool by name
- *
- * Activation: CODE_MODE_ENABLED=true
- *
- * @module tools/code-mode
- */
-
-const { registerTool } = require('.');
-const { listServers, ensureClient } = require('../mcp');
-const config = require('../config');
-const logger = require('../logger');
-
-// ── Tool List Cache ─────────────────────────────────────────────────
-
-let toolListCache = null;
-let toolListCacheTs = 0;
-
-function getCacheTtl() {
-  return config.mcp?.codeMode?.toolListCacheTtl || 60_000;
-}
-
-/**
- * Fetch tool lists from all MCP servers, with caching.
- * @param {string} [filterServerId] - Optional: only fetch from this server
- * @param {boolean} [forceRefresh] - Bypass cache
- * @returns {Promise<Object>} { serverId: [{ name, description }] }
- */
-async function fetchToolList(filterServerId, forceRefresh = false) {
-  const now = Date.now();
-  if (!forceRefresh && toolListCache && (now - toolListCacheTs < getCacheTtl())) {
-    if (filterServerId) {
-      return { [filterServerId]: toolListCache[filterServerId] || [] };
-    }
-    return toolListCache;
-  }
-
-  const servers = listServers();
-  const result = {};
-
-  await Promise.all(
-    servers.map(async (server) => {
-      if (filterServerId && server.id !== filterServerId) return;
-      try {
-        const client = await ensureClient(server.id);
-        if (!client) {
-          result[server.id] = { error: 'Server not available' };
-          return;
-        }
-        const response = await client.request('tools/list', {});
-        const tools = Array.isArray(response?.tools) ? response.tools : [];
-        result[server.id] = tools.map(t => ({
-          name: t.name ?? t.method ?? 'unknown',
-          description: (t.description || '').substring(0, 100),
-        }));
-      } catch (err) {
-        result[server.id] = { error: err.message };
-      }
-    })
-  );
-
-  // Update cache if we fetched all servers
-  if (!filterServerId) {
-    toolListCache = result;
-    toolListCacheTs = now;
-  }
-
-  return filterServerId ? { [filterServerId]: result[filterServerId] || [] } : result;
-}
-
-/**
- * Fetch full tool schema for a specific tool on a specific server.
- * @param {string} serverId
- * @param {string} toolName
- * @returns {Promise<Object|null>}
- */
-async function fetchToolSchema(serverId, toolName) {
-  const client = await ensureClient(serverId);
-  if (!client) return null;
-
-  const response = await client.request('tools/list', {});
-  const tools = Array.isArray(response?.tools) ? response.tools : [];
-  return tools.find(t => (t.name ?? t.method) === toolName) || null;
-}
-
-/**
- * Generate a usage example from a tool's input schema.
- * @param {Object} tool - Tool definition with inputSchema
- * @returns {string} Example JSON
- */
-function generateExample(tool) {
-  const schema = tool.inputSchema || tool.input_schema || {};
-  const props = schema.properties || {};
-  const example = {};
-
-  for (const [key, def] of Object.entries(props)) {
-    if (def.type === 'string') example[key] = def.example || `<${key}>`;
-    else if (def.type === 'number' || def.type === 'integer') example[key] = def.example || 0;
-    else if (def.type === 'boolean') example[key] = def.example ?? true;
-    else if (def.type === 'array') example[key] = [];
-    else if (def.type === 'object') example[key] = {};
-    else example[key] = null;
-  }
-
-  return JSON.stringify(example, null, 2);
-}
-
-// ── Meta-Tool Registration ──────────────────────────────────────────
-
-function registerCodeModeTools() {
-  // 1. mcp_list_tools — discover available tools
-  registerTool(
-    'mcp_list_tools',
-    async ({ args = {} }) => {
-      const serverId = args.server_id || null;
-      const forceRefresh = args.force_refresh === true;
-      const result = await fetchToolList(serverId, forceRefresh);
-
-      // Add summary stats
-      let totalTools = 0;
-      for (const tools of Object.values(result)) {
-        if (Array.isArray(tools)) totalTools += tools.length;
-      }
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify({ total_tools: totalTools, servers: result }, null, 2),
-      };
-    },
-    {
-      category: 'code-mode',
-      description: 'List all available MCP tools across all servers. Returns tool names and brief descriptions. Use this first to discover what tools are available.',
-      input_schema: {
-        type: 'object',
-        properties: {
-          server_id: { type: 'string', description: 'Optional: filter to a specific MCP server ID' },
-          force_refresh: { type: 'boolean', description: 'Bypass cache and refresh tool list' },
-        },
-      },
-    }
-  );
-
-  // 2. mcp_tool_info — load full schema for one tool
-  registerTool(
-    'mcp_tool_info',
-    async ({ args = {} }) => {
-      const serverId = args.server_id;
-      const toolName = args.tool_name;
-
-      if (!serverId || !toolName) {
-        throw new Error('mcp_tool_info requires server_id and tool_name');
-      }
-
-      const tool = await fetchToolSchema(serverId, toolName);
-      if (!tool) {
-        throw new Error(`Tool "${toolName}" not found on server "${serverId}"`);
-      }
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify({
-          server: serverId,
-          name: tool.name ?? tool.method,
-          description: tool.description || '',
-          inputSchema: tool.inputSchema || tool.input_schema || {},
-        }, null, 2),
-      };
-    },
-    {
-      category: 'code-mode',
-      description: 'Get the full schema and detailed description for a specific MCP tool. Use after mcp_list_tools to get the exact parameters needed before calling mcp_execute.',
-      input_schema: {
-        type: 'object',
-        properties: {
-          server_id: { type: 'string', description: 'MCP server ID' },
-          tool_name: { type: 'string', description: 'Tool name from mcp_list_tools' },
-        },
-        required: ['server_id', 'tool_name'],
-      },
-    }
-  );
-
-  // 3. mcp_tool_docs — usage examples
-  registerTool(
-    'mcp_tool_docs',
-    async ({ args = {} }) => {
-      const serverId = args.server_id;
-      const toolName = args.tool_name;
-
-      if (!serverId || !toolName) {
-        throw new Error('mcp_tool_docs requires server_id and tool_name');
-      }
-
-      const tool = await fetchToolSchema(serverId, toolName);
-      if (!tool) {
-        throw new Error(`Tool "${toolName}" not found on server "${serverId}"`);
-      }
-
-      const schema = tool.inputSchema || tool.input_schema || {};
-      const params = Object.entries(schema.properties || {}).map(([name, def]) => ({
-        name,
-        type: def.type || 'any',
-        required: (schema.required || []).includes(name),
-        description: def.description || '',
-      }));
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify({
-          server: serverId,
-          tool: tool.name ?? tool.method,
-          description: tool.description || '',
-          parameters: params,
-          example_arguments: generateExample(tool),
-          usage: `Use mcp_execute with server_id="${serverId}", tool_name="${toolName}", and arguments matching the schema above.`,
-        }, null, 2),
-      };
-    },
-    {
-      category: 'code-mode',
-      description: 'Get usage documentation, parameter details, and example arguments for an MCP tool.',
-      input_schema: {
-        type: 'object',
-        properties: {
-          server_id: { type: 'string', description: 'MCP server ID' },
-          tool_name: { type: 'string', description: 'Tool name' },
-        },
-        required: ['server_id', 'tool_name'],
-      },
-    }
-  );
-
-  // 4. mcp_execute — execute a tool by name
-  registerTool(
-    'mcp_execute',
-    async ({ args = {} }) => {
-      const serverId = args.server_id;
-      const toolName = args.tool_name;
-      const toolArgs = args.arguments ?? {};
-
-      if (!serverId || !toolName) {
-        throw new Error('mcp_execute requires server_id and tool_name');
-      }
-
-      const client = await ensureClient(serverId.trim());
-      if (!client) {
-        throw new Error(`MCP server "${serverId}" is not available.`);
-      }
-
-      const result = await client.request(toolName.trim(), toolArgs);
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify({
-          server: serverId,
-          tool: toolName,
-          result,
-        }, null, 2),
-        metadata: { server: serverId, tool: toolName },
-      };
-    },
-    {
-      category: 'code-mode',
-      description: 'Execute an MCP tool by name with JSON arguments. First use mcp_list_tools to discover tools, then mcp_tool_info to get the schema, then this tool to execute.',
-      input_schema: {
-        type: 'object',
-        properties: {
-          server_id: { type: 'string', description: 'MCP server ID' },
-          tool_name: { type: 'string', description: 'Tool method name' },
-          arguments: {
-            type: 'object',
-            description: 'JSON arguments matching the tool input schema',
-            additionalProperties: true,
-          },
-        },
-        required: ['server_id', 'tool_name'],
-      },
-    }
-  );
-
-  logger.info('[code-mode] Registered 4 meta-tools: mcp_list_tools, mcp_tool_info, mcp_tool_docs, mcp_execute');
-}
-
-module.exports = {
-  registerCodeModeTools,
-  // Exported for testing
-  fetchToolList,
-  fetchToolSchema,
-  generateExample,
-};