lynkr 0.1.0

package/src/tests/store.js

@@ -0,0 +1,213 @@
+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/edits.js

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,169 @@
+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) {
+  if (!cwd) return workspaceRoot;
+  return resolveWorkspacePath(cwd);
+}
+
+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 = {} }) => {
+      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);
+      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 = {} }) => {
+      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);
+      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,
+};