lynkr 9.9.1 → 9.10.0

package/src/tools/index.js

@@ -1,306 +0,0 @@
-const logger = require("../logger");
-const { truncateToolOutput } = require("./truncate");
-
-const registry = new Map();
-const registryLowercase = new Map();
-
-// Lazy loader reference (set after module load to avoid circular deps)
-let lazyLoader = null;
-
-/**
- * Set the lazy loader module (called from server.js)
- * @param {Object} loader - The lazy-loader module
- */
-function setLazyLoader(loader) {
-  lazyLoader = loader;
-}
-
-const TOOL_ALIASES = {
-  bash: "shell",
-  shell: "shell",
-  sh: "shell",
-  terminal: "shell",
-  grep: "workspace_search",
-  search: "workspace_search",
-  find: "workspace_search",
-  websearch: "web_search",
-  web_search: "web_search",
-  "Web Search": "web_search",
-  WebSearch: "web_search",
-  web_fetch: "web_fetch",
-  webfetch: "web_fetch",
-  web_agent: "web_agent",
-  webagent: "web_agent",
-  WebAgent: "web_agent",
-  tinyfish: "web_agent",
-  task: "Task",
-  write: "fs_write",
-  filewrite: "fs_write",
-  read: "fs_read",
-  fileread: "fs_read",
-  patch: "edit_patch",
-  edit: "edit_patch",
-  list: "workspace_list",
-  ls: "workspace_list",
-  dir: "workspace_list",
-  summary: "project_summary",
-  projectsummary: "project_summary",
-  overview: "project_summary",
-  reindex: "workspace_index_rebuild",
-  index: "workspace_index_rebuild",
-  scan: "workspace_index_rebuild",
-  history: "workspace_edit_history",
-  edits: "workspace_edit_history",
-  undo: "workspace_edit_revert",
-  revert: "workspace_edit_revert",
-  diff: "workspace_diff",
-  diffsummary: "workspace_diff_summary",
-  summarizediff: "workspace_diff_summary",
-  diffsum: "workspace_diff_summary",
-  symbol: "workspace_symbol_search",
-  symbols: "workspace_symbol_search",
-  findsymbol: "workspace_symbol_search",
-  symbolsearch: "workspace_symbol_search",
-  references: "workspace_symbol_references",
-  ref: "workspace_symbol_references",
-  findreferences: "workspace_symbol_references",
-  usages: "workspace_symbol_references",
-  status: "workspace_git_status",
-  stage: "workspace_git_stage",
-  unstage: "workspace_git_unstage",
-  commit: "workspace_git_commit",
-  push: "workspace_git_push",
-  pull: "workspace_git_pull",
-  branches: "workspace_git_branches",
-  checkout: "workspace_git_checkout",
-  branch: "workspace_git_checkout",
-  stash: "workspace_git_stash",
-  review: "workspace_diff_review",
-  releasenotes: "workspace_release_notes",
-  diffstat: "workspace_diff_by_commit",
-  merge: "workspace_git_merge",
-  rebase: "workspace_git_rebase",
-  conflicts: "workspace_git_conflicts",
-  patchplan: "workspace_git_patch_plan",
-  changelog: "workspace_changelog_generate",
-  prtemplate: "workspace_pr_template_generate",
-  sandbox: "workspace_sandbox_sessions",
-  mcpsessions: "workspace_sandbox_sessions",
-  mcpservers: "workspace_mcp_servers",
-  tests: "workspace_test_summary",
-  testrun: "workspace_test_run",
-  runtests: "workspace_test_run",
-  testsummary: "workspace_test_summary",
-  testhistory: "workspace_test_history",
-};
-
-function coerceString(value) {
-  if (value === undefined || value === null) return "";
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value, null, 2);
-  } catch {
-    return String(value);
-  }
-}
-
-function normalizeHandlerResult(result) {
-  if (typeof result === "string") {
-    return {
-      ok: true,
-      status: 200,
-      content: result,
-      metadata: {},
-    };
-  }
-  if (result === undefined || result === null) {
-    return {
-      ok: true,
-      status: 200,
-      content: "",
-      metadata: {},
-    };
-  }
-  const ok = result.ok ?? true;
-  const status = result.status ?? (ok ? 200 : 500);
-  const content = coerceString(result.content ?? result.output ?? result.data ?? "");
-  const metadata = result.metadata ?? {};
-  return { ok, status, content, metadata };
-}
-
-function parseArguments(call) {
-  const raw = call?.function?.arguments;
-  if (typeof raw !== "string" || raw.trim().length === 0) return {};
-  try {
-    return JSON.parse(raw);
-  } catch (err) {
-    logger.warn({ err }, "Failed to parse tool arguments");
-    return {};
-  }
-}
-
-function normaliseToolCall(call) {
-  const name = call?.function?.name ?? call?.name;
-  const id = call?.id ?? `${name ?? "tool"}_${Date.now()}`;
-  return {
-    id,
-    name,
-    arguments: parseArguments(call),
-    raw: call,
-  };
-}
-
-function registerTool(name, handler, options = {}) {
-  if (!name || typeof name !== "string") {
-    throw new Error("Tool name must be a non-empty string.");
-  }
-  if (typeof handler !== "function") {
-    throw new Error(`Tool "${name}" must be registered with a function handler.`);
-  }
-  registry.set(name, { handler, options });
-  registryLowercase.set(name.toLowerCase(), { handler, options, original: name });
-  logger.debug({ tool: name }, "Tool registered");
-}
-
-function hasTool(name) {
-  return registry.has(name);
-}
-
-function getTool(name) {
-  logger.debug({ tool: name }, "Getting tool");
-  if (!name) return undefined;
-  const direct = registry.get(name);
-  if (direct) return direct;
-  const lower = registryLowercase.get(name.toLowerCase());
-  if (lower) return registry.get(lower.original);
-  const aliasTarget = TOOL_ALIASES[name.toLowerCase()];
-  if (aliasTarget) {
-    const aliasEntry = registry.get(aliasTarget);
-    if (aliasEntry) return aliasEntry;
-  }
-  return undefined;
-}
-
-function listTools() {
-  return Array.from(registry.keys());
-}
-
-async function executeToolCall(call, context = {}) {
-  const normalisedCall = normaliseToolCall(call);
-  let registered = registry.get(normalisedCall.name);
-  if (!registered) {
-    const aliasTarget = TOOL_ALIASES[normalisedCall.name.toLowerCase()];
-    if (aliasTarget) {
-      registered = registry.get(aliasTarget);
-      if (registered) {
-        normalisedCall.name = aliasTarget;
-      }
-    }
-  }
-  if (!registered) {
-    const lowerEntry = registryLowercase.get(normalisedCall.name.toLowerCase());
-    if (lowerEntry) {
-      registered = registry.get(lowerEntry.original);
-      normalisedCall.name = lowerEntry.original;
-    }
-  }
-
-  // Lazy loading: If tool not found, try to load its category
-  if (!registered && lazyLoader) {
-    const loaded = lazyLoader.loadCategoryForTool(normalisedCall.name);
-    if (loaded) {
-      // Retry lookup after loading
-      registered = registry.get(normalisedCall.name);
-      if (!registered) {
-        const aliasTarget = TOOL_ALIASES[normalisedCall.name.toLowerCase()];
-        if (aliasTarget) {
-          registered = registry.get(aliasTarget);
-          if (registered) normalisedCall.name = aliasTarget;
-        }
-      }
-      if (!registered) {
-        const lowerEntry = registryLowercase.get(normalisedCall.name.toLowerCase());
-        if (lowerEntry) {
-          registered = registry.get(lowerEntry.original);
-          normalisedCall.name = lowerEntry.original;
-        }
-      }
-    }
-  }
-
-  if (!registered) {
-    const content = coerceString({
-      error: "tool_not_registered",
-      tool: normalisedCall.name,
-      input: normalisedCall.arguments,
-    });
-    return {
-      id: normalisedCall.id,
-      name: normalisedCall.name,
-      arguments: normalisedCall.arguments,
-      ok: false,
-      status: 404,
-      content,
-      metadata: { registered: false },
-    };
-  }
-
-  try {
-    const result = await registered.handler(
-      {
-        id: normalisedCall.id,
-        name: normalisedCall.name,
-        args: normalisedCall.arguments,
-        raw: normalisedCall.raw,
-      },
-      context,
-    );
-    const formatted = normalizeHandlerResult(result);
-
-    const truncatedContent = truncateToolOutput(normalisedCall.name, formatted.content);
-
-    return {
-      id: normalisedCall.id,
-      name: normalisedCall.name,
-      arguments: normalisedCall.arguments,
-      ...formatted,
-      content: truncatedContent,
-      metadata: {
-        ...(formatted.metadata ?? {}),
-        registered: true,
-        truncated: truncatedContent !== formatted.content,
-        originalLength: formatted.content?.length,
-        truncatedLength: truncatedContent?.length,
-      },
-    };
-  } catch (err) {
-    logger.error({ err, tool: normalisedCall.name }, "Tool execution failed");
-    return {
-      id: normalisedCall.id,
-      name: normalisedCall.name,
-      arguments: normalisedCall.arguments,
-      ok: false,
-      status: 500,
-      content: coerceString({
-        error: "tool_execution_failed",
-        tool: normalisedCall.name,
-        message: err.message,
-      }),
-      metadata: {
-        registered: true,
-        error: true,
-      },
-      error: err,
-    };
-  }
-}
-
-module.exports = {
-  registerTool,
-  hasTool,
-  getTool,
-  listTools,
-  executeToolCall,
-  setLazyLoader,
-  TOOL_ALIASES,
-};

package/src/tools/indexer.js

@@ -1,360 +0,0 @@
-const {
-  listWorkspaceFiles,
-  searchWorkspace,
-  rebuildWorkspaceIndex,
-  getProjectSummary,
-  searchSymbols,
-  searchSymbolReferences,
-  findDefinitionNearLocation,
-  listDefinitionsBySymbol,
-} = require("../indexer");
-const { registerTool } = require(".");
-const { getTaskSummary } = require("../tasks/store");
-const { getTestSummary } = require("../tests");
-
-function registerWorkspaceListTool() {
-  registerTool(
-    "workspace_list",
-    async ({ args = {} }) => {
-      const patterns =
-        typeof args.patterns === "string"
-          ? [args.patterns]
-          : Array.isArray(args.patterns)
-          ? args.patterns
-          : undefined;
-      const ignore =
-        typeof args.ignore === "string"
-          ? [args.ignore]
-          : Array.isArray(args.ignore)
-          ? args.ignore
-          : undefined;
-      const limit = Number.isInteger(args.limit) ? args.limit : undefined;
-      const withStats = args.with_stats === true || args.include_stats === true;
-      const includeDirectories = args.include_directories === true;
-
-      const entries = await listWorkspaceFiles({
-        patterns,
-        ignore,
-        limit,
-        withStats,
-        includeDirectories,
-      });
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify({ entries }, null, 2),
-        metadata: {
-          total: entries.length,
-        },
-      };
-    },
-    { category: "indexing" },
-  );
-}
-
-function registerWorkspaceSearchTool() {
-  registerTool(
-    "workspace_search",
-    async ({ args = {} }) => {
-      const query = args.query ?? args.term ?? args.pattern;
-      const regex = args.regex === true || args.is_regex === true;
-      const limit = Number.isInteger(args.limit) ? args.limit : undefined;
-      const ignore =
-        typeof args.ignore === "string"
-          ? [args.ignore]
-          : Array.isArray(args.ignore)
-          ? args.ignore
-          : undefined;
-
-      const result = await searchWorkspace({
-        query,
-        regex,
-        limit,
-        ignore,
-      });
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(result, null, 2),
-        metadata: {
-          total: result.matches.length,
-          engine: result.engine,
-        },
-      };
-    },
-    { category: "indexing" },
-  );
-}
-
-function registerWorkspaceRebuildTool() {
-  registerTool(
-    "workspace_index_rebuild",
-    async ({ args = {} }) => {
-      const patterns =
-        typeof args.patterns === "string"
-          ? [args.patterns]
-          : Array.isArray(args.patterns)
-          ? args.patterns
-          : undefined;
-      const ignore =
-        typeof args.ignore === "string"
-          ? [args.ignore]
-          : Array.isArray(args.ignore)
-          ? args.ignore
-          : undefined;
-
-      const summary = await rebuildWorkspaceIndex({
-        patterns,
-        ignore,
-      });
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(summary, null, 2),
-        metadata: {
-          fileCount: summary.fileCount,
-          languages: summary.languages,
-          frameworks: summary.frameworks,
-        },
-      };
-    },
-    { category: "indexing" },
-  );
-}
-
-function registerProjectSummaryTool() {
-  registerTool(
-    "project_summary",
-    async ({ args = {} }) => {
-      let summary = getProjectSummary();
-      if (args.rebuild === true || args.refresh === true) {
-        summary = await rebuildWorkspaceIndex({});
-      }
-
-      const tasksLimitRaw =
-        args.tasks_limit ?? args.tasksLimit ?? args.tasks_sample ?? args.tasksSample;
-      const tasks = getTaskSummary({
-        limit:
-          tasksLimitRaw === undefined || tasksLimitRaw === null
-            ? undefined
-            : Number.isFinite(Number(tasksLimitRaw))
-            ? Number(tasksLimitRaw)
-            : undefined,
-      });
-
-      const tests = getTestSummary({
-        includeRecent: args.tests_recent === true || args.testsRecent === true,
-        recentLimit:
-          args.tests_recent_limit ?? args.testsRecentLimit ?? args.tests_recent_sample ?? args.testsRecentSample,
-      });
-
-      const payload = {
-        ...summary,
-        tasks,
-        tests,
-      };
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(payload, null, 2),
-        metadata: {
-          fileCount: summary.fileCount,
-          languages: summary.languages,
-          frameworks: summary.frameworks,
-          tasks: tasks.total,
-          tests: tests.totalRuns ?? 0,
-        },
-      };
-    },
-    { category: "indexing" },
-  );
-}
-
-function registerSymbolSearchTool() {
-  registerTool(
-    "workspace_symbol_search",
-    async ({ args = {} }) => {
-      const query = args.query ?? args.name ?? args.symbol;
-      const limit =
-        typeof args.limit === "number" && args.limit > 0 ? Math.min(args.limit, 100) : 50;
-      const language =
-        typeof args.language === "string" ? args.language.toLowerCase() : undefined;
-      const file =
-        typeof args.path === "string"
-          ? args.path
-          : typeof args.file === "string"
-          ? args.file
-          : undefined;
-
-      const results = searchSymbols({
-        query,
-        language,
-        limit,
-        filePath: file,
-      });
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(
-          {
-            query,
-            language,
-            file,
-            results,
-          },
-          null,
-          2,
-        ),
-        metadata: {
-          total: results.length,
-        },
-      };
-    },
-    { category: "indexing" },
-  );
-}
-
-function registerSymbolReferencesTool() {
-  registerTool(
-    "workspace_symbol_references",
-    async ({ args = {} }) => {
-      const symbol = args.symbol ?? args.name ?? args.query;
-      const limit =
-        typeof args.limit === "number" && args.limit > 0 ? Math.min(args.limit, 100) : 50;
-      const file =
-        typeof args.path === "string"
-          ? args.path
-          : typeof args.file === "string"
-          ? args.file
-          : undefined;
-
-      const results = searchSymbolReferences({
-        symbol,
-        filePath: file,
-        limit,
-      });
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(
-          {
-            symbol,
-            file,
-            results,
-          },
-          null,
-          2,
-        ),
-        metadata: {
-          total: results.length,
-        },
-      };
-    },
-    { category: "indexing" },
-  );
-}
-
-function registerGotoDefinitionTool() {
-  registerTool(
-    "workspace_goto_definition",
-    async ({ args = {} }) => {
-      const filePath =
-        typeof args.file === "string"
-          ? args.file
-          : typeof args.path === "string"
-          ? args.path
-          : null;
-      const line =
-        typeof args.line === "number"
-          ? args.line
-          : typeof args.row === "number"
-          ? args.row
-          : null;
-      const column =
-        typeof args.column === "number"
-          ? args.column
-          : typeof args.col === "number"
-          ? args.col
-          : null;
-      const symbolName =
-        typeof args.symbol === "string"
-          ? args.symbol
-          : typeof args.name === "string"
-          ? args.name
-          : null;
-
-      if (filePath && line) {
-        const rows = findDefinitionNearLocation({ filePath, line, column });
-        return {
-          ok: true,
-          status: 200,
-          content: JSON.stringify(
-            {
-              filePath,
-              line,
-              column: column ?? null,
-              results: rows.map((row) => ({
-                symbol: row.name,
-                kind: row.kind,
-                definition: {
-                  filePath: row.definition_path,
-                  line: row.definition_line,
-                  column: row.definition_column,
-                },
-                reference: {
-                  filePath: row.reference_path,
-                  line: row.reference_line,
-                  column: row.reference_column,
-                  snippet: row.snippet ?? null,
-                },
-              })),
-            },
-            null,
-            2,
-          ),
-        };
-      }
-
-      if (symbolName) {
-        const rows = listDefinitionsBySymbol({ name: symbolName });
-        return {
-          ok: true,
-          status: 200,
-          content: JSON.stringify(
-            {
-              symbol: symbolName,
-              definitions: rows,
-            },
-            null,
-            2,
-          ),
-        };
-      }
-
-      throw new Error(
-        "workspace_goto_definition requires either (file,line[,column]) or symbol name.",
-      );
-    },
-    { category: "indexing" },
-  );
-}
-
-function registerIndexerTools() {
-  registerWorkspaceListTool();
-  registerWorkspaceSearchTool();
-  registerWorkspaceRebuildTool();
-  registerProjectSummaryTool();
-  registerSymbolSearchTool();
-  registerSymbolReferencesTool();
-  registerGotoDefinitionTool();
-}
-
-module.exports = {
-  registerIndexerTools,
-};