lynkr 9.9.1 → 9.10.0

package/src/tools/decompose.js

@@ -1,91 +0,0 @@
-const { registerTool } = require(".");
-const { runDecomposedTask } = require("../agents/decomposition");
-const logger = require("../logger");
-
-/**
- * DecomposeTask tool — breaks a complex task into focused subtasks with isolated
- * context, runs them (parallel where independent), and synthesizes the result.
- *
- * Opt-in: requires TASK_DECOMPOSITION_ENABLED=true and AGENTS_ENABLED=true.
- * Degrades gracefully — if the gate decides decomposition isn't worth it (or
- * planning fails), it returns ok:true with decomposed:false and a reason so the
- * caller can solve the task monolithically.
- */
-function registerDecomposeTool() {
-  registerTool(
-    "DecomposeTask",
-    async ({ args = {} }, context = {}) => {
-      const task = args.task || args.prompt || args.description;
-
-      if (!task || typeof task !== "string") {
-        return {
-          ok: false,
-          status: 400,
-          content: JSON.stringify({ error: "task is required" }, null, 2),
-        };
-      }
-
-      logger.info(
-        { task: task.slice(0, 100), sessionId: context.sessionId },
-        "DecomposeTask: evaluating task for decomposition"
-      );
-
-      try {
-        const result = await runDecomposedTask(task, {
-          sessionId: context.sessionId,
-          cwd: context.cwd,
-          riskLevel: args.riskLevel || context.riskLevel,
-        });
-
-        if (result.decomposed) {
-          return {
-            ok: true,
-            status: 200,
-            content: result.result,
-            metadata: {
-              decomposed: true,
-              subtasks: result.plan?.subtasks?.length,
-              levels: result.stats?.levels,
-              strategy: result.plan?.strategy,
-              confidence: result.quality?.confidence,
-              recommendFallback: result.recommendFallback,
-              savedTokens: result.savings?.savedTokens,
-            },
-          };
-        }
-
-        // Not decomposed — signal the caller to solve monolithically.
-        return {
-          ok: true,
-          status: 200,
-          content: JSON.stringify(
-            {
-              decomposed: false,
-              reason: result.reason,
-              guidance: "Solve this task directly without decomposition.",
-            },
-            null,
-            2
-          ),
-          metadata: { decomposed: false, reason: result.reason },
-        };
-      } catch (error) {
-        logger.error({ error: error.message }, "DecomposeTask: error");
-        return {
-          ok: false,
-          status: 500,
-          content: JSON.stringify(
-            { error: "Decomposition error", message: error.message },
-            null,
-            2
-          ),
-        };
-      }
-    },
-    { category: "decompose" }
-  );
-
-  logger.info("DecomposeTask tool registered");
-}
-
-module.exports = { registerDecomposeTool };

package/src/tools/edits.js

@@ -1,94 +0,0 @@
-const { getEditHistory, revertEdit } = require("../edits");
-const { registerTool } = require(".");
-const logger = require("../logger");
-
-function registerEditHistoryTool() {
-  registerTool(
-    "workspace_edit_history",
-    async ({ args = {} }) => {
-      const limit =
-        typeof args.limit === "number" && args.limit > 0 ? Math.min(args.limit, 100) : 20;
-      const filePath =
-        typeof args.path === "string"
-          ? args.path
-          : typeof args.file === "string"
-          ? args.file
-          : undefined;
-      const sessionId =
-        typeof args.session_id === "string"
-          ? args.session_id
-          : typeof args.sessionId === "string"
-          ? args.sessionId
-          : undefined;
-
-      const history = getEditHistory({ filePath, sessionId, limit });
-      return {
-        ok: true,
-        status: 200,
-        content: JSON.stringify(
-          {
-            edits: history,
-            limit,
-            filePath,
-            sessionId,
-          },
-          null,
-          2,
-        ),
-        metadata: {
-          count: history.length,
-        },
-      };
-    },
-    { category: "workspace" },
-  );
-}
-
-function registerEditRevertTool() {
-  registerTool(
-    "workspace_edit_revert",
-    async ({ args = {} }, context = {}) => {
-      const editId = args.id ?? args.edit_id ?? args.editId;
-      if (typeof editId !== "number" && typeof editId !== "string") {
-        throw new Error("workspace_edit_revert requires an edit id (numeric).");
-      }
-      const numericId = Number(editId);
-      if (Number.isNaN(numericId)) {
-        throw new Error("Edit id must be numeric.");
-      }
-      const sessionId = context.session?.id ?? context.sessionId ?? null;
-      try {
-        const result = await revertEdit({ editId: numericId, sessionId });
-        return {
-          ok: true,
-          status: 200,
-          content: JSON.stringify(
-            {
-              revertedEditId: result.revertedEditId,
-              filePath: result.filePath,
-            },
-            null,
-            2,
-          ),
-          metadata: {
-            revertedEditId: result.revertedEditId,
-            filePath: result.filePath,
-          },
-        };
-      } catch (err) {
-        logger.warn({ err, editId: numericId }, "Failed to revert edit");
-        throw err;
-      }
-    },
-    { category: "workspace" },
-  );
-}
-
-function registerEditTools() {
-  registerEditHistoryTool();
-  registerEditRevertTool();
-}
-
-module.exports = {
-  registerEditTools,
-};

package/src/tools/execution.js

@@ -1,171 +0,0 @@
-const path = require("path");
-const { runProcess, MAX_TIMEOUT_MS, DEFAULT_TIMEOUT_MS } = require("./process");
-const { registerTool } = require(".");
-const { workspaceRoot, resolveWorkspacePath } = require("../workspace");
-
-function parseTimeout(value) {
-  if (value === undefined || value === null) return DEFAULT_TIMEOUT_MS;
-  const parsed = Number.parseInt(value, 10);
-  if (Number.isNaN(parsed) || parsed <= 0) return DEFAULT_TIMEOUT_MS;
-  return Math.min(parsed, MAX_TIMEOUT_MS);
-}
-
-function normaliseCwd(cwd, contextCwd) {
-  // Priority: explicit cwd arg > context.cwd > workspaceRoot
-  if (cwd) return resolveWorkspacePath(cwd);
-  if (contextCwd) return contextCwd; // Already validated absolute path
-  return workspaceRoot;
-}
-
-function parseSandboxMode(value) {
-  if (typeof value !== "string") return "auto";
-  const mode = value.trim().toLowerCase();
-  if (mode === "always" || mode === "never" || mode === "auto") {
-    return mode;
-  }
-  return "auto";
-}
-
-function formatProcessResult(result) {
-  return JSON.stringify(
-    {
-      stdout: result.stdout,
-      stderr: result.stderr,
-      exit_code: result.exitCode,
-      signal: result.signal,
-      timed_out: result.timedOut,
-      duration_ms: result.durationMs,
-      stdout_overflow: result.stdoutOverflow,
-      stderr_overflow: result.stderrOverflow,
-    },
-    null,
-    2,
-  );
-}
-
-function registerShellTool() {
-  registerTool(
-    "shell",
-    async ({ args = {} }, context = {}) => {
-      const command = args.command ?? args.cmd ?? args.run ?? args.input;
-      const commandArgs = Array.isArray(args.args) ? args.args.map(String) : [];
-      const cwd = normaliseCwd(args.cwd, context.cwd);
-      const timeoutMs = parseTimeout(args.timeout_ms ?? args.timeout);
-
-      let spawnCommand;
-      let spawnArgs;
-      let useShell = false;
-
-      if (typeof command === "string" && command.trim().length > 0) {
-        spawnCommand = "bash";
-        spawnArgs = ["-lc", command];
-        useShell = false;
-      } else if (Array.isArray(command) && command.length > 0) {
-        spawnCommand = String(command[0]);
-        spawnArgs = command.slice(1).map(String).concat(commandArgs);
-      } else if (
-        typeof args.args === "string" &&
-        args.args.trim().length > 0 &&
-        !command
-      ) {
-        spawnCommand = "bash";
-        spawnArgs = ["-lc", args.args];
-      } else {
-        throw new Error("shell tool requires a command string or array.");
-      }
-
-      const sandbox = parseSandboxMode(args.sandbox ?? args.isolation);
-
-      const result = await runProcess({
-        command: spawnCommand,
-        args: spawnArgs,
-        cwd,
-        env: args.env,
-        timeoutMs,
-        shell: useShell,
-        sandbox,
-        sessionId: args.session_id ?? args.sessionId ?? null,
-      });
-
-      const ok = result.exitCode === 0 && !result.timedOut;
-      const status = result.timedOut ? 408 : ok ? 200 : 500;
-
-      return {
-        ok,
-        status,
-        content: formatProcessResult(result),
-        metadata: {
-          command: spawnCommand,
-          args: spawnArgs,
-          cwd,
-        },
-      };
-    },
-    { category: "execution" },
-  );
-}
-
-function registerPythonTool() {
-  registerTool(
-    "python_exec",
-    async ({ args = {} }, context = {}) => {
-      const code =
-        typeof args.code === "string"
-          ? args.code
-          : typeof args.script === "string"
-          ? args.script
-          : typeof args.input === "string"
-          ? args.input
-          : null;
-
-      if (!code) {
-        throw new Error("python_exec requires a code string.");
-      }
-
-      const executable = args.executable ?? args.python ?? "python3";
-      const cwd = normaliseCwd(args.cwd, context.cwd);
-      const timeoutMs = parseTimeout(args.timeout_ms ?? args.timeout);
-      const requirements = Array.isArray(args.requirements) ? args.requirements : [];
-
-      // Basic support: write code to stdin; requirements handling is TODO.
-      const sandbox = parseSandboxMode(args.sandbox ?? args.isolation);
-
-      const result = await runProcess({
-        command: executable,
-        args: ["-"],
-        cwd,
-        env: args.env,
-        timeoutMs,
-        input: code,
-        sandbox,
-        sessionId: args.session_id ?? args.sessionId ?? null,
-      });
-
-      const ok = result.exitCode === 0 && !result.timedOut;
-      const status = result.timedOut ? 408 : ok ? 200 : 500;
-
-      return {
-        ok,
-        status,
-        content: formatProcessResult(result),
-        metadata: {
-          executable: path.basename(executable),
-          cwd,
-          requirements,
-        },
-      };
-    },
-    { category: "execution" },
-  );
-}
-
-function registerExecutionTools() {
-  registerShellTool();
-  registerPythonTool();
-}
-
-module.exports = {
-  registerExecutionTools,
-  registerShellTool,
-  registerPythonTool,
-};