u-foo 1.0.6 → 1.1.9

package/src/code/runtime.js

@@ -0,0 +1,154 @@
+const fs = require("fs");
+const path = require("path");
+const { runToolCall } = require("./dispatch");
+
+function getRuntimePaths(projectRoot = process.cwd()) {
+  const root = path.resolve(projectRoot || process.cwd());
+  const runtimeDir = path.join(root, ".ufoo", "agent", "ucode-core");
+  return {
+    projectRoot: root,
+    runtimeDir,
+    tasksFile: path.join(runtimeDir, "tasks.jsonl"),
+    resultsFile: path.join(runtimeDir, "results.jsonl"),
+    stateFile: path.join(runtimeDir, "state.json"),
+  };
+}
+
+function ensureRuntimeDir(projectRoot = process.cwd()) {
+  const { runtimeDir } = getRuntimePaths(projectRoot);
+  fs.mkdirSync(runtimeDir, { recursive: true });
+}
+
+function parseJsonLines(filePath = "") {
+  try {
+    if (!fs.existsSync(filePath)) return [];
+    const raw = fs.readFileSync(filePath, "utf8");
+    if (!raw.trim()) return [];
+    const rows = [];
+    for (const line of raw.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) {
+      try {
+        rows.push(JSON.parse(line));
+      } catch {
+        // ignore malformed line
+      }
+    }
+    return rows;
+  } catch {
+    return [];
+  }
+}
+
+function appendJsonLine(filePath = "", payload = {}) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, `${JSON.stringify(payload)}\n`, "utf8");
+}
+
+function loadState(projectRoot = process.cwd()) {
+  const { stateFile } = getRuntimePaths(projectRoot);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+    const offset = Number.isFinite(parsed.offset) ? Math.max(0, Math.floor(parsed.offset)) : 0;
+    return { offset };
+  } catch {
+    return { offset: 0 };
+  }
+}
+
+function saveState(projectRoot = process.cwd(), state = {}) {
+  const { stateFile } = getRuntimePaths(projectRoot);
+  fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+  fs.writeFileSync(stateFile, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+function createTaskId() {
+  return `task-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function normalizeTask(input = {}) {
+  const tool = String(input.tool || input.name || "").trim().toLowerCase();
+  const args = input.args && typeof input.args === "object" ? input.args : {};
+  return {
+    task_id: String(input.task_id || input.taskId || createTaskId()).trim(),
+    created_at: new Date().toISOString(),
+    tool,
+    args,
+    workspace_root: String(input.workspace_root || input.workspaceRoot || "").trim(),
+    meta: input.meta && typeof input.meta === "object" ? input.meta : {},
+  };
+}
+
+function submitTask(projectRoot = process.cwd(), input = {}) {
+  ensureRuntimeDir(projectRoot);
+  const task = normalizeTask(input);
+  const { tasksFile } = getRuntimePaths(projectRoot);
+  appendJsonLine(tasksFile, task);
+  return task;
+}
+
+function normalizeMax(value, fallback = 1) {
+  if (!Number.isFinite(value)) return fallback;
+  const n = Math.max(1, Math.floor(value));
+  return Math.min(n, 500);
+}
+
+function runOnce(projectRoot = process.cwd(), options = {}) {
+  ensureRuntimeDir(projectRoot);
+  const paths = getRuntimePaths(projectRoot);
+  const state = loadState(projectRoot);
+  const tasks = parseJsonLines(paths.tasksFile);
+  const startOffset = Number.isFinite(state.offset) ? state.offset : 0;
+  const maxTasks = normalizeMax(options.maxTasks, 1);
+  const selected = tasks.slice(startOffset, startOffset + maxTasks);
+  const results = [];
+
+  for (const task of selected) {
+    const startedAt = new Date().toISOString();
+    const run = runToolCall(
+      { tool: task.tool, args: task.args },
+      {
+        workspaceRoot: task.workspace_root || options.workspaceRoot || projectRoot,
+        cwd: projectRoot,
+      }
+    );
+    const finishedAt = new Date().toISOString();
+    const resultEntry = {
+      task_id: String(task.task_id || ""),
+      tool: String(task.tool || ""),
+      ok: run.ok !== false,
+      error: run && typeof run.error === "string" ? run.error : "",
+      output: run,
+      started_at: startedAt,
+      finished_at: finishedAt,
+      created_at: String(task.created_at || ""),
+    };
+    appendJsonLine(paths.resultsFile, resultEntry);
+    results.push(resultEntry);
+  }
+
+  const nextOffset = startOffset + selected.length;
+  saveState(projectRoot, { offset: nextOffset });
+  return {
+    processed: selected.length,
+    offset: nextOffset,
+    results,
+  };
+}
+
+function listResults(projectRoot = process.cwd(), options = {}) {
+  const paths = getRuntimePaths(projectRoot);
+  const rows = parseJsonLines(paths.resultsFile);
+  const num = normalizeMax(options.num, 20);
+  if (rows.length <= num) return rows;
+  return rows.slice(rows.length - num);
+}
+
+module.exports = {
+  getRuntimePaths,
+  ensureRuntimeDir,
+  parseJsonLines,
+  loadState,
+  saveState,
+  submitTask,
+  runOnce,
+  listResults,
+};

package/src/code/sessionStore.js

@@ -0,0 +1,162 @@
+const fs = require("fs");
+const path = require("path");
+const { randomUUID } = require("crypto");
+
+function getSessionsDir(workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot || process.cwd());
+  return path.join(root, ".ufoo", "agent", "ucode-core", "sessions");
+}
+
+function normalizeSessionId(value = "") {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]{2,127}$/.test(raw)) return "";
+  return raw;
+}
+
+function createSessionId(prefix = "ucode") {
+  const safePrefix = String(prefix || "ucode").trim().replace(/[^a-zA-Z0-9_-]+/g, "") || "ucode";
+  return `${safePrefix}-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+}
+
+function resolveSessionId(value = "") {
+  const normalized = normalizeSessionId(value);
+  if (normalized) return normalized;
+  return createSessionId("ucode");
+}
+
+function toIsoNow() {
+  return new Date().toISOString();
+}
+
+function cloneMessages(value = []) {
+  if (!Array.isArray(value)) return [];
+  try {
+    const parsed = JSON.parse(JSON.stringify(value));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((entry) => entry && typeof entry === "object" && !Array.isArray(entry));
+  } catch {
+    return [];
+  }
+}
+
+function buildSessionSnapshot(input = {}) {
+  const source = input && typeof input === "object" ? input : {};
+  const sessionId = resolveSessionId(source.sessionId);
+  const createdAt = String(source.createdAt || "").trim() || toIsoNow();
+  return {
+    version: 1,
+    sessionId,
+    workspaceRoot: String(source.workspaceRoot || process.cwd()).trim() || process.cwd(),
+    provider: String(source.provider || "").trim(),
+    model: String(source.model || "").trim(),
+    context: String(source.context || ""),
+    nlMessages: cloneMessages(source.nlMessages),
+    createdAt,
+    updatedAt: toIsoNow(),
+  };
+}
+
+function getSessionFilePath(workspaceRoot = process.cwd(), sessionId = "") {
+  const normalizedId = normalizeSessionId(sessionId);
+  if (!normalizedId) return "";
+  return path.join(getSessionsDir(workspaceRoot), `${normalizedId}.json`);
+}
+
+function saveSessionSnapshot(workspaceRoot = process.cwd(), snapshot = {}) {
+  const normalizedRoot = path.resolve(workspaceRoot || process.cwd());
+  const payload = buildSessionSnapshot({
+    ...snapshot,
+    workspaceRoot: normalizedRoot,
+  });
+  const filePath = getSessionFilePath(normalizedRoot, payload.sessionId);
+  if (!filePath) {
+    return {
+      ok: false,
+      error: "invalid session id",
+      sessionId: "",
+      filePath: "",
+    };
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    return {
+      ok: true,
+      error: "",
+      sessionId: payload.sessionId,
+      filePath,
+      snapshot: payload,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "failed to save session",
+      sessionId: payload.sessionId,
+      filePath,
+    };
+  }
+}
+
+function loadSessionSnapshot(workspaceRoot = process.cwd(), sessionId = "") {
+  const normalizedRoot = path.resolve(workspaceRoot || process.cwd());
+  const normalizedId = normalizeSessionId(sessionId);
+  if (!normalizedId) {
+    return {
+      ok: false,
+      error: "invalid session id",
+      sessionId: "",
+      snapshot: null,
+      filePath: "",
+    };
+  }
+
+  const filePath = getSessionFilePath(normalizedRoot, normalizedId);
+  if (!filePath || !fs.existsSync(filePath)) {
+    return {
+      ok: false,
+      error: `session not found: ${normalizedId}`,
+      sessionId: normalizedId,
+      snapshot: null,
+      filePath: filePath || "",
+    };
+  }
+
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const snapshot = buildSessionSnapshot({
+      ...parsed,
+      sessionId: normalizedId,
+      workspaceRoot: normalizedRoot,
+      createdAt: parsed && parsed.createdAt ? parsed.createdAt : "",
+    });
+    return {
+      ok: true,
+      error: "",
+      sessionId: normalizedId,
+      snapshot,
+      filePath,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "failed to load session",
+      sessionId: normalizedId,
+      snapshot: null,
+      filePath,
+    };
+  }
+}
+
+module.exports = {
+  getSessionsDir,
+  normalizeSessionId,
+  createSessionId,
+  resolveSessionId,
+  buildSessionSnapshot,
+  getSessionFilePath,
+  saveSessionSnapshot,
+  loadSessionSnapshot,
+};

package/src/code/taskDecomposer.js

@@ -0,0 +1,269 @@
+/**
+ * Task decomposition and progress reporting for ucode
+ * Based on Claude Code's design principles
+ */
+
+const { runNativeAgentTask } = require("./nativeRunner");
+
+/**
+ * Decompose a bug fix task into manageable steps
+ */
+function decomposeBugFixTask(task) {
+  const steps = [];
+
+  // Analyze task to determine if it's a bug fix
+  const isBugFix = /fix|bug|issue|problem|error|broken|doesn't work|not work/i.test(task);
+
+  if (isBugFix) {
+    steps.push({
+      id: "identify",
+      name: "Identifying the issue",
+      prompt: `Identify the specific problem: ${task}\n\nBe concise. Focus only on:\n1. What is broken\n2. What file/function is likely involved\n3. What the expected behavior should be\n\nDo NOT analyze entire codebases. Find the specific issue quickly.`,
+      timeoutMs: 30000, // 30 seconds
+      earlyExit: true,
+    });
+
+    steps.push({
+      id: "locate",
+      name: "Locating relevant code",
+      prompt: `Based on the identified issue, find the exact location of the bug.\n\nSearch for and read ONLY the relevant function/file. Stop as soon as you find the problematic code.`,
+      timeoutMs: 30000,
+      earlyExit: true,
+    });
+
+    steps.push({
+      id: "fix",
+      name: "Applying the fix",
+      prompt: `Apply the minimal fix needed. Do NOT refactor or improve unrelated code. Just fix the specific issue.`,
+      timeoutMs: 60000,
+      earlyExit: false,
+    });
+
+    steps.push({
+      id: "verify",
+      name: "Verifying the fix",
+      prompt: `Verify the fix resolves the issue. Check that:\n1. The specific problem is fixed\n2. No new issues were introduced\n\nBe brief.`,
+      timeoutMs: 20000,
+      earlyExit: false,
+    });
+  } else {
+    // For non-bug tasks, use a single step
+    steps.push({
+      id: "execute",
+      name: "Executing task",
+      prompt: task,
+      timeoutMs: 120000,
+      earlyExit: false,
+    });
+  }
+
+  return steps;
+}
+
+/**
+ * Run a task with decomposition and progress reporting
+ */
+async function runDecomposedTask({
+  task,
+  state,
+  onProgress,
+  onToolEvent,
+  signal,
+  workspaceRoot,
+  provider,
+  model,
+  systemPrompt,
+  messages = [],
+  sessionId = "",
+}) {
+  const steps = decomposeBugFixTask(task);
+  const results = [];
+  let aborted = false;
+
+  // Check if already aborted
+  if (signal && signal.aborted) {
+    return {
+      ok: false,
+      error: "Task aborted",
+      results,
+    };
+  }
+
+  for (const step of steps) {
+    // Check abort signal
+    if (signal && signal.aborted) {
+      aborted = true;
+      break;
+    }
+
+    // Report progress
+    if (onProgress) {
+      onProgress({
+        type: "step_start",
+        step: step.id,
+        name: step.name,
+        current: steps.indexOf(step) + 1,
+        total: steps.length,
+      });
+    }
+
+    try {
+      // Run the step with its own timeout
+      const stepResult = await runNativeAgentTask({
+        workspaceRoot,
+        provider,
+        model,
+        prompt: step.prompt,
+        systemPrompt,
+        messages,
+        sessionId,
+        timeoutMs: step.timeoutMs,
+        onToolEvent,
+        signal,
+      });
+
+      results.push({
+        step: step.id,
+        name: step.name,
+        result: stepResult,
+      });
+
+      // Report step completion
+      if (onProgress) {
+        onProgress({
+          type: "step_complete",
+          step: step.id,
+          name: step.name,
+          success: stepResult.ok,
+        });
+      }
+
+      // Early exit if solution found
+      if (step.earlyExit && stepResult.ok) {
+        const output = String(stepResult.output || "").toLowerCase();
+        if (output.includes("fixed") || output.includes("resolved") || output.includes("solution")) {
+          // Found the fix early, skip remaining analysis
+          break;
+        }
+      }
+
+      // Stop on error for critical steps
+      if (!stepResult.ok && (step.id === "identify" || step.id === "locate")) {
+        return {
+          ok: false,
+          error: `Failed at ${step.name}: ${stepResult.error}`,
+          results,
+        };
+      }
+
+    } catch (err) {
+      // Report step error
+      if (onProgress) {
+        onProgress({
+          type: "step_error",
+          step: step.id,
+          name: step.name,
+          error: err.message,
+        });
+      }
+
+      return {
+        ok: false,
+        error: `Error at ${step.name}: ${err.message}`,
+        results,
+      };
+    }
+  }
+
+  if (aborted) {
+    return {
+      ok: false,
+      error: "Task aborted by user",
+      results,
+    };
+  }
+
+  // Compile final summary
+  const summary = compileSummary(results);
+
+  return {
+    ok: true,
+    summary,
+    results,
+  };
+}
+
+/**
+ * Compile results into a concise summary
+ */
+function compileSummary(results) {
+  if (!results || results.length === 0) {
+    return "No results";
+  }
+
+  // Extract key information from each step
+  const summaryParts = [];
+
+  for (const stepResult of results) {
+    if (stepResult.result && stepResult.result.ok) {
+      const output = String(stepResult.result.output || "").trim();
+
+      // Extract only the important parts (skip verbose thinking)
+      const lines = output.split("\n");
+      const keyLines = lines.filter(line => {
+        const lower = line.toLowerCase();
+        // Keep lines with actual findings/actions
+        return (
+          lower.includes("fixed") ||
+          lower.includes("found") ||
+          lower.includes("issue") ||
+          lower.includes("problem") ||
+          lower.includes("solution") ||
+          lower.includes("edit") ||
+          lower.includes("changed") ||
+          line.includes("src/") ||
+          line.includes("✓") ||
+          line.includes("✅")
+        );
+      });
+
+      if (keyLines.length > 0) {
+        summaryParts.push(keyLines.slice(0, 3).join("\n"));
+      }
+    }
+  }
+
+  return summaryParts.join("\n\n");
+}
+
+/**
+ * Create a progress reporter that sends updates via bus
+ */
+function createBusProgressReporter(shell, publisher) {
+  let lastReportTime = Date.now();
+  const MIN_REPORT_INTERVAL = 5000; // Report at most every 5 seconds
+
+  return (progress) => {
+    const now = Date.now();
+    if (now - lastReportTime < MIN_REPORT_INTERVAL) {
+      return; // Throttle progress reports
+    }
+
+    lastReportTime = now;
+
+    if (progress.type === "step_start") {
+      const message = `⏳ ${progress.name} (${progress.current}/${progress.total})`;
+      shell(`ufoo bus send ${publisher} ${JSON.stringify(message)}`);
+    } else if (progress.type === "step_complete" && progress.success) {
+      const message = `✅ ${progress.name} completed`;
+      shell(`ufoo bus send ${publisher} ${JSON.stringify(message)}`);
+    }
+  };
+}
+
+module.exports = {
+  decomposeBugFixTask,
+  runDecomposedTask,
+  compileSummary,
+  createBusProgressReporter,
+};

package/src/code/tools/bash.js

@@ -0,0 +1,53 @@
+const { spawnSync } = require("child_process");
+const { normalizeWorkspaceRoot } = require("./common");
+
+function runBashTool(input = {}, options = {}) {
+  try {
+    const command = String(input.command || "").trim();
+    if (!command) {
+      return {
+        ok: false,
+        error: "command is required",
+      };
+    }
+    const workspaceRoot = normalizeWorkspaceRoot(options.workspaceRoot, options.cwd);
+    const timeoutMs = Number.isFinite(input.timeoutMs) ? Math.max(100, Math.floor(input.timeoutMs)) : 60000;
+    const result = spawnSync(command, {
+      cwd: workspaceRoot,
+      shell: true,
+      timeout: timeoutMs,
+      encoding: "utf8",
+      maxBuffer: 2 * 1024 * 1024,
+    });
+
+    if (result.error) {
+      return {
+        ok: false,
+        workspaceRoot,
+        code: typeof result.status === "number" ? result.status : -1,
+        stdout: String(result.stdout || ""),
+        stderr: String(result.stderr || ""),
+        error: result.error.message || "bash failed",
+      };
+    }
+
+    const code = typeof result.status === "number" ? result.status : 0;
+    return {
+      ok: code === 0,
+      workspaceRoot,
+      code,
+      stdout: String(result.stdout || ""),
+      stderr: String(result.stderr || ""),
+      error: code === 0 ? "" : `command exited with ${code}`,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "bash failed",
+    };
+  }
+}
+
+module.exports = {
+  runBashTool,
+};

package/src/code/tools/common.js

@@ -0,0 +1,42 @@
+const fs = require("fs");
+const path = require("path");
+
+function normalizeWorkspaceRoot(workspaceRoot = "", cwd = process.cwd()) {
+  const base = String(workspaceRoot || "").trim();
+  return path.resolve(base || cwd || process.cwd());
+}
+
+function isPathInside(root, target) {
+  const normalizedRoot = path.resolve(root);
+  const normalizedTarget = path.resolve(target);
+  if (normalizedRoot === normalizedTarget) return true;
+  return normalizedTarget.startsWith(`${normalizedRoot}${path.sep}`);
+}
+
+function resolveWorkspacePath(workspaceRoot = "", targetPath = "", cwd = process.cwd()) {
+  const root = normalizeWorkspaceRoot(workspaceRoot, cwd);
+  const requested = String(targetPath || "").trim();
+  if (!requested) {
+    throw new Error("path is required");
+  }
+  const resolved = path.resolve(root, requested);
+  if (!isPathInside(root, resolved)) {
+    throw new Error("path escapes workspace root");
+  }
+  return {
+    workspaceRoot: root,
+    requested,
+    resolved,
+  };
+}
+
+function ensureParentDir(filePath = "") {
+  const dir = path.dirname(path.resolve(filePath));
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+module.exports = {
+  normalizeWorkspaceRoot,
+  resolveWorkspacePath,
+  ensureParentDir,
+};