lynkr 9.9.1 → 9.10.0

package/src/tools/process.js

@@ -1,167 +0,0 @@
-const { spawn } = require("child_process");
-const path = require("path");
-const { workspaceRoot, resolveWorkspacePath } = require("../workspace");
-const { isSandboxEnabled, runSandboxProcess } = require("../mcp/sandbox");
-
-const DEFAULT_TIMEOUT_MS = 15000;
-const MAX_TIMEOUT_MS = 900000;
-const MAX_BUFFER_BYTES = 1024 * 1024; // 1MB
-
-function sanitiseEnv(env = {}) {
-  const output = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (typeof key !== "string") continue;
-    if (value === undefined || value === null) continue;
-    output[key] = typeof value === "string" ? value : String(value);
-  }
-  return output;
-}
-
-function normaliseTimeout(timeoutMs) {
-  if (!Number.isFinite(timeoutMs)) return DEFAULT_TIMEOUT_MS;
-  if (timeoutMs <= 0) return DEFAULT_TIMEOUT_MS;
-  return Math.min(timeoutMs, MAX_TIMEOUT_MS);
-}
-
-function normaliseSandboxPreference(value) {
-  switch (value) {
-    case "always":
-    case "never":
-    case "auto":
-      return value;
-    default:
-      return "never";
-  }
-}
-
-async function runProcess({
-  command,
-  args = [],
-  input,
-  cwd,
-  env,
-  timeoutMs,
-  maxBuffer = MAX_BUFFER_BYTES,
-  shell = false,
-  sandbox = "never",
-  sessionId = null,
-}) {
-  if (!command || typeof command !== "string") {
-    throw new Error("Command must be a non-empty string.");
-  }
-  // cwd can be:
-  // 1. An already-resolved absolute path (from normaliseCwd in execution.js)
-  // 2. A relative path that needs resolving against workspaceRoot
-  // 3. null/undefined (use workspaceRoot)
-  let resolvedCwd;
-  if (cwd) {
-    // If it's already an absolute path, use it directly
-    // Otherwise resolve against workspaceRoot
-    if (path.isAbsolute(cwd)) {
-      resolvedCwd = cwd;
-    } else {
-      resolvedCwd = resolveWorkspacePath(cwd);
-    }
-  } else {
-    resolvedCwd = workspaceRoot;
-  }
-  const mergedEnv = { ...process.env, ...sanitiseEnv(env) };
-  const timeout = normaliseTimeout(timeoutMs ?? DEFAULT_TIMEOUT_MS);
-  const sandboxPreference = normaliseSandboxPreference(sandbox);
-
-  if (sandboxPreference === "always" && !isSandboxEnabled()) {
-    throw new Error("Sandbox execution requested but sandbox is not enabled.");
-  }
-
-  const shouldUseSandbox =
-    sandboxPreference === "always" ||
-    (sandboxPreference === "auto" && isSandboxEnabled());
-
-  if (shouldUseSandbox) {
-    return runSandboxProcess({
-      sessionId,
-      command,
-      args,
-      input,
-      cwd: resolvedCwd,
-      env: mergedEnv,
-      timeoutMs: timeout,
-      maxBuffer,
-    });
-  }
-
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: resolvedCwd,
-      env: mergedEnv,
-      shell,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let stderr = "";
-    let stdoutOverflow = false;
-    let stderrOverflow = false;
-    const start = Date.now();
-    let timedOut = false;
-
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, timeout);
-
-    const appendBuffer = (current, chunk) => {
-      if (current.length >= maxBuffer) return { value: current, overflow: true };
-      const next = current + chunk;
-      if (next.length > maxBuffer) {
-        return { value: next.slice(0, maxBuffer), overflow: true };
-      }
-      return { value: next, overflow: false };
-    };
-
-    child.stdout.on("data", (chunk) => {
-      const { value, overflow } = appendBuffer(stdout, chunk.toString());
-      stdout = value;
-      if (overflow) stdoutOverflow = true;
-    });
-
-    child.stderr.on("data", (chunk) => {
-      const { value, overflow } = appendBuffer(stderr, chunk.toString());
-      stderr = value;
-      if (overflow) stderrOverflow = true;
-    });
-
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-
-    child.on("close", (code, signal) => {
-      clearTimeout(timer);
-      resolve({
-        exitCode: code,
-        signal,
-        stdout,
-        stderr,
-        stdoutOverflow,
-        stderrOverflow,
-        timedOut,
-        durationMs: Date.now() - start,
-      });
-    });
-
-    if (typeof input === "string" && child.stdin.writable) {
-      child.stdin.write(input);
-      child.stdin.end();
-    } else if (!input && child.stdin.writable) {
-      child.stdin.end();
-    }
-  });
-}
-
-module.exports = {
-  runProcess,
-  DEFAULT_TIMEOUT_MS,
-  MAX_TIMEOUT_MS,
-  MAX_BUFFER_BYTES,
-};

package/src/tools/smart-selection.js

@@ -1,180 +0,0 @@
-/**
- * Smart Tool Selection — Conservative Stripping
- *
- * Strategy: instead of predicting which tools ARE needed (brittle regex),
- * only strip groups we are CERTAIN are irrelevant based on clear absence
- * of intent signals.
- *
- * Rules:
- *   1. Greeting → strip everything
- *   2. No write intent → strip Write / Edit / NotebookEdit
- *   3. No execution intent → strip Bash / KillShell
- *   4. No web intent → strip WebSearch / WebFetch
- *
- * File ops (Read, Grep, Glob) are NEVER stripped — they are the most
- * broadly useful and the most commonly needed unexpectedly.
- */
-
-const logger = require('../logger');
-
-const SYSTEM_REMINDER_PATTERN = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
-
-// Clear greeting — strip all tools
-const GREETING_PATTERN = /^(hi|hello|hey|good morning|good afternoon|good evening|howdy|greetings|sup|yo)[\s\.\!\?]*$/i;
-const TECHNICAL_KEYWORDS = /code|function|class|file|module|import|export|async|await|promise|api|database|server|component|variable|array|object|\.[a-z]{1,5}\b|npm|git|docker|python|node|bash|run|install/i;
-
-// Intent signals — absence means we strip that group
-const WRITE_INTENT   = /write|create\b|add to|update|modify|change|fix|delete|remove|insert|append|replace|save|edit|refactor|rename|move|reorganize|rewrite|implement|generate|produce|scaffold/i;
-const EXECUTE_INTENT = /run|execute|test|compile|build|deploy|start|install|launch|boot|npm|yarn|pnpm|git|python|node|docker|bash|sh\b|cmd|script|make|cargo|go run/i;
-const WEB_INTENT     = /search online|search the web|search google|look up online|browse|website|https?:\/\//i;
-
-// Tools always kept (file search is never useless)
-const ALWAYS_KEEP = new Set([
-  'Read', 'Grep', 'Glob',
-  'Task', 'TaskOutput', 'TodoWrite', 'TodoRead',
-  'AskUserQuestion', 'Skill',
-  'EnterPlanMode', 'ExitPlanMode',
-]);
-
-// Conditional strips: group → intent pattern that must be present to keep it
-const CONDITIONAL_GROUPS = [
-  { names: ['Write', 'Edit', 'NotebookEdit'],  intent: WRITE_INTENT   },
-  { names: ['Bash', 'KillShell'],              intent: EXECUTE_INTENT },
-  { names: ['WebSearch', 'WebFetch'],          intent: WEB_INTENT     },
-];
-
-// Legacy map kept for telemetry label compatibility
-const TOOL_SELECTION_MAP = {
-  conversational:    [],
-  simple_qa:         [],
-  file_reading:      ['Read', 'Grep', 'Glob'],
-  file_modification: ['Read', 'Write', 'Edit', 'Grep', 'Glob', 'Bash'],
-  code_execution:    ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob'],
-  coding:            ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob'],
-  research:          ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'],
-  complex_task:      ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'WebSearch', 'WebFetch', 'Task', 'TodoWrite', 'AskUserQuestion'],
-};
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function getLastUserContent(payload) {
-  if (!Array.isArray(payload.messages)) return '';
-  for (let i = payload.messages.length - 1; i >= 0; i--) {
-    const msg = payload.messages[i];
-    if (msg?.role !== 'user') continue;
-    let text = '';
-    if (typeof msg.content === 'string') {
-      text = msg.content;
-    } else if (Array.isArray(msg.content)) {
-      text = msg.content.filter(b => b?.type === 'text').map(b => b.text || '').join(' ');
-    }
-    return text.replace(SYSTEM_REMINDER_PATTERN, '').trim();
-  }
-  return '';
-}
-
-function isGreeting(content) {
-  const t = content.trim();
-  return GREETING_PATTERN.test(t) || (t.length < 20 && !TECHNICAL_KEYWORDS.test(t));
-}
-
-// ─── Classifier (conservative) ───────────────────────────────────────────────
-
-/**
- * Classify request and compute which tool groups to strip.
- * Returns a classification object for logging/telemetry compatibility.
- */
-function classifyRequestType(payload) {
-  const content = getLastUserContent(payload);
-  const lower   = content.toLowerCase();
-  const msgCount = payload.messages?.length ?? 0;
-
-  // Greeting → strip everything
-  if (isGreeting(lower)) {
-    return { type: 'conversational', confidence: 1.0, keywords: ['greeting'], _stripped: ['Write', 'Edit', 'NotebookEdit', 'Bash', 'KillShell', 'WebSearch', 'WebFetch'] };
-  }
-
-  const stripped = [];
-  for (const { names, intent } of CONDITIONAL_GROUPS) {
-    if (!intent.test(lower)) stripped.push(...names);
-  }
-
-  // Derive a label for telemetry
-  const hasWrite = WRITE_INTENT.test(lower);
-  const hasExec  = EXECUTE_INTENT.test(lower);
-  const hasWeb   = WEB_INTENT.test(lower);
-
-  const type = hasWrite || hasExec ? 'file_modification'
-    : hasWeb   ? 'research'
-    : msgCount > 10 ? 'complex_task'
-    : 'file_reading';
-
-  return { type, confidence: 0.9, keywords: ['conservative'], _stripped: stripped };
-}
-
-// ─── Tool filter ─────────────────────────────────────────────────────────────
-
-function estimateToolTokens(tools) {
-  if (!Array.isArray(tools)) return 0;
-  return tools.length * 175;
-}
-
-/**
- * Apply conservative stripping to the tool list.
- */
-function recordStrippingSavings(before, after) {
-  if (after >= before) return;
-  try {
-    const telemetry = require('../routing/telemetry');
-    telemetry.recordSavings('tool_stripping', (before - after) * 175);
-  } catch { /* telemetry is best-effort */ }
-}
-
-function selectToolsSmartly(tools, classification, options = {}) {
-  if (!Array.isArray(tools) || tools.length === 0) return tools;
-
-  const { provider = 'databricks' } = options;
-  const strippedNames = new Set(classification._stripped ?? []);
-
-  // Greeting: strip everything
-  if (classification.type === 'conversational') {
-    recordStrippingSavings(tools.length, 0);
-    return [];
-  }
-
-  // Strip only the flagged groups; always keep ALWAYS_KEEP tools
-  let selected = tools.filter(tool => {
-    const name = String(tool.name || '');
-    if (ALWAYS_KEEP.has(name)) return true;
-    return !strippedNames.has(name);
-  });
-
-  // Safety: if we somehow stripped everything, return full list
-  if (selected.length === 0) return tools;
-
-  // Code Mode meta-tools always included
-  const codeConfig = require('../config');
-  if (codeConfig.mcp?.codeMode?.enabled) {
-    const codeModeNames = new Set(['mcp_list_tools', 'mcp_tool_info', 'mcp_tool_docs', 'mcp_execute']);
-    for (const tool of tools) {
-      if (codeModeNames.has(tool.name) && !selected.some(t => t.name === tool.name)) {
-        selected.push(tool);
-      }
-    }
-  }
-
-  // Ollama has a smaller context — cap at 10 tools
-  if (provider === 'ollama' && selected.length > 10) {
-    selected = selected.slice(0, 10);
-  }
-
-  recordStrippingSavings(tools.length, selected.length);
-  return selected;
-}
-
-module.exports = {
-  classifyRequestType,
-  selectToolsSmartly,
-  estimateToolTokens,
-  TOOL_SELECTION_MAP,
-};

package/src/tools/stubs.js

@@ -1,55 +0,0 @@
-const { registerTool, hasTool } = require(".");
-
-const STUB_TOOLS = [
-  {
-    name: "fs_read",
-    description: "Read file contents from the active workspace.",
-  },
-  {
-    name: "fs_write",
-    description: "Write or create files within the active workspace.",
-  },
-  {
-    name: "edit_patch",
-    description: "Apply unified diff patches to workspace files.",
-  },
-  {
-    name: "shell",
-    description: "Execute shell commands inside the workspace sandbox.",
-  },
-  {
-    name: "python_exec",
-    description: "Run Python snippets in the managed runtime.",
-  },
-  {
-    name: "web_search",
-    description: "Perform a web search and return summarized results.",
-  },
-];
-
-function createStubHandler(name, description) {
-  return async ({ args }) => ({
-    ok: false,
-    status: 501,
-    content: {
-      error: "tool_not_implemented",
-      tool: name,
-      description,
-      input: args,
-      hint: "This is a stub tool. Implement a real handler to enable this capability.",
-    },
-  });
-}
-
-function registerStubTools() {
-  STUB_TOOLS.forEach((tool) => {
-    if (!hasTool(tool.name)) {
-      registerTool(tool.name, createStubHandler(tool.name, tool.description), tool);
-    }
-  });
-}
-
-module.exports = {
-  STUB_TOOLS,
-  registerStubTools,
-};

package/src/tools/tasks.js

@@ -1,260 +0,0 @@
-const {
-  createTask,
-  listTasks,
-  getTaskById,
-  updateTask,
-  deleteTask,
-  setTaskStatus,
-} = require("../tasks/store");
-const { registerTool } = require(".");
-
-function normaliseTagsInput(value) {
-  if (value === undefined) return undefined;
-  if (Array.isArray(value)) {
-    return value
-      .map((item) => (typeof item === "string" ? item.trim() : null))
-      .filter((item) => item && item.length > 0);
-  }
-  if (typeof value === "string") {
-    return value
-      .split(",")
-      .map((item) => item.trim())
-      .filter((item) => item.length > 0);
-  }
-  return undefined;
-}
-
-function normaliseMetadataInput(value) {
-  if (value === undefined) return undefined;
-  if (value === null) return null;
-  if (typeof value === "object") return value;
-  if (typeof value === "string") {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return { note: value };
-    }
-  }
-  return undefined;
-}
-
-function parseLimit(limit) {
-  if (limit === undefined || limit === null) return undefined;
-  const num = Number(limit);
-  if (!Number.isFinite(num)) return undefined;
-  const int = Math.trunc(num);
-  if (int <= 0) return undefined;
-  return Math.min(int, 500);
-}
-
-function registerTaskTools() {
-  registerTool(
-    "workspace_tasks_list",
-    async ({ args = {} }) => {
-      const tasks = listTasks({
-        status: typeof args.status === "string" ? args.status.trim() : undefined,
-        linkedFile:
-          typeof args.file === "string"
-            ? args.file
-            : typeof args.path === "string"
-            ? args.path
-            : undefined,
-        search: typeof args.search === "string" ? args.search : undefined,
-        limit: parseLimit(args.limit),
-        orderBy: typeof args.order === "string" ? args.order : undefined,
-      });
-
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(
-          {
-            tasks,
-            total: tasks.length,
-          },
-          null,
-          2,
-        ),
-        metadata: {
-          count: tasks.length,
-        },
-      };
-    },
-    { category: "tasks" },
-  );
-
-  registerTool(
-    "workspace_task_get",
-    async ({ args = {} }) => {
-      const id = Number.parseInt(args.id ?? args.task_id ?? args.taskId, 10);
-      if (!Number.isFinite(id)) {
-        throw new Error("workspace_task_get requires a numeric id.");
-      }
-      const task = getTaskById(id);
-      if (!task) {
-        return {
-          ok: false,
-          status: 404,
-          content: JSON.stringify(
-            {
-              error: "task_not_found",
-              id,
-            },
-            null,
-            2,
-          ),
-          metadata: {
-            id,
-            found: false,
-          },
-        };
-      }
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(task, null, 2),
-        metadata: {
-          id,
-        },
-      };
-    },
-    { category: "tasks" },
-  );
-
-  registerTool(
-    "workspace_task_create",
-    async ({ args = {} }, context = {}) => {
-      const title = args.title ?? args.name ?? args.summary;
-      if (typeof title !== "string" || !title.trim()) {
-        throw new Error("workspace_task_create requires a title.");
-      }
-
-      const tags = normaliseTagsInput(args.tags);
-      const metadata = normaliseMetadataInput(args.metadata);
-      const task = createTask({
-        title,
-        status: typeof args.status === "string" ? args.status.trim() : "todo",
-        priority:
-          Number.isFinite(args.priority) || Number.isFinite(Number(args.priority))
-            ? Number(args.priority)
-            : 0,
-        tags,
-        linkedFile:
-          typeof args.file === "string"
-            ? args.file
-            : typeof args.path === "string"
-            ? args.path
-            : null,
-        createdBy: context.session?.id ?? context.sessionId ?? null,
-        metadata,
-      });
-
-      return {
-        ok: true,
-        status: 201,
-        content: JSON.stringify(task, null, 2),
-        metadata: {
-          id: task.id,
-        },
-      };
-    },
-    { category: "tasks" },
-  );
-
-  registerTool(
-    "workspace_task_update",
-    async ({ args = {} }, context = {}) => {
-      const id = Number.parseInt(args.id ?? args.task_id ?? args.taskId, 10);
-      if (!Number.isFinite(id)) {
-        throw new Error("workspace_task_update requires a numeric id.");
-      }
-
-      const updates = {};
-      if (args.title !== undefined) updates.title = args.title;
-      if (args.status !== undefined) updates.status = args.status;
-      if (args.priority !== undefined) updates.priority = Number(args.priority);
-      const tags = normaliseTagsInput(args.tags);
-      if (tags !== undefined) updates.tags = tags;
-      if (args.file !== undefined || args.path !== undefined) {
-        updates.linkedFile =
-          typeof args.file === "string"
-            ? args.file
-            : typeof args.path === "string"
-            ? args.path
-            : null;
-      }
-      const metadata = normaliseMetadataInput(args.metadata);
-      if (metadata !== undefined) updates.metadata = metadata;
-
-      updates.updatedBy = context.session?.id ?? context.sessionId ?? null;
-
-      const task = updateTask(id, updates);
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(task, null, 2),
-        metadata: {
-          id: task.id,
-        },
-      };
-    },
-    { category: "tasks" },
-  );
-
-  registerTool(
-    "workspace_task_set_status",
-    async ({ args = {} }, context = {}) => {
-      const id = Number.parseInt(args.id ?? args.task_id ?? args.taskId, 10);
-      if (!Number.isFinite(id)) {
-        throw new Error("workspace_task_set_status requires a numeric id.");
-      }
-      const status = args.status ?? args.state;
-      if (typeof status !== "string" || !status.trim()) {
-        throw new Error("workspace_task_set_status requires a non-empty status.");
-      }
-      const task = setTaskStatus(id, status.trim(), context.session?.id ?? context.sessionId ?? null);
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(task, null, 2),
-        metadata: {
-          id: task.id,
-          status: task.status,
-        },
-      };
-    },
-    { category: "tasks" },
-  );
-
-  registerTool(
-    "workspace_task_delete",
-    async ({ args = {} }) => {
-      const id = Number.parseInt(args.id ?? args.task_id ?? args.taskId, 10);
-      if (!Number.isFinite(id)) {
-        throw new Error("workspace_task_delete requires a numeric id.");
-      }
-      const deleted = deleteTask(id);
-      return {
-        ok: deleted,
-        status: deleted ? 200 : 404,
-        content: JSON.stringify(
-          {
-            id,
-            deleted,
-          },
-          null,
-          2,
-        ),
-        metadata: {
-          id,
-          deleted,
-        },
-      };
-    },
-    { category: "tasks" },
-  );
-}
-
-module.exports = {
-  registerTaskTools,
-};