u-foo 2.5.14 → 3.0.0

package/src/code/context/promptLayers.js

@@ -0,0 +1,175 @@
+"use strict";
+
+const {
+  getIdentitySection,
+} = require("../../agents/prompts/native/identity");
+const {
+  getSystemSection,
+} = require("../../agents/prompts/native/system");
+const {
+  getDoingTasksSection,
+} = require("../../agents/prompts/native/tasks");
+const {
+  getActionsSection,
+} = require("../../agents/prompts/native/actions");
+const {
+  getSafetySection,
+} = require("../../agents/prompts/native/safety");
+const {
+  getOutputEfficiencySection,
+} = require("../../agents/prompts/native/efficiency");
+const {
+  getUfooIntegrationSection,
+} = require("../../agents/prompts/native/ufoo");
+const {
+  getSessionStableEnvironmentSection,
+  getTurnDynamicEnvironmentSection,
+} = require("../../agents/prompts/native/environment");
+const {
+  listUcodeSkills,
+  renderSkillsSection,
+} = require("../skills");
+const { hashContent } = require("./artifacts");
+
+const PROMPT_VERSION = "native-v5";
+
+function buildImmutablePrefix() {
+  return [
+    `promptVersion: ${PROMPT_VERSION}`,
+    getIdentitySection(),
+    getSystemSection(),
+    getDoingTasksSection(),
+    getActionsSection(),
+    getSafetySection(),
+    getOutputEfficiencySection(),
+    [
+      "Tool calling grammar:",
+      "- Use read, write, edit, bash, and artifact_read for direct work, even when it takes several tool calls. Use plan_graph only when the work needs a durable semantic/executable plan, explicit dependencies or checkpoints, or asynchronous TaskRuns.",
+      "- Plan Mode is a runtime posture for the Agent Loop, not an agent tool. While Plan Mode is ON, direct write, edit, and bash calls from the Agent Loop are blocked; read and artifact_read remain available.",
+      "- In the Agent Loop, plan_graph operation=create automatically enables Plan Mode. The user may also use /plan on or /plan off.",
+      "- Turning Plan Mode off does not cancel an existing graph or running TaskRuns. Use plan_graph operation=cancel_graph or operation=control with cancel_task to stop them.",
+      "- When the user enables Plan Mode and no active graph exists, create a plan_graph before performing side effects.",
+      "- Use plan_graph for durable graph structure and TaskRun lifecycle: create, patch, inspect, cancel_graph, and control.",
+      "- After an accepted plan_graph create or patch, Runtime automatically advances ready tool nodes. Never invent or request an execute_graph tool.",
+      "- Do not call plan_graph together with read, write, edit, bash, or artifact_read in the same assistant turn.",
+      "- When an active graph is waiting on a task, advance that node through plan_graph instead of bypassing it with direct workspace tools: use patch.expand_node for execution.kind=expand, control.complete_task (nodeId) for execution.kind=inline_llm, or control.start_task for execution.kind=task_loop.",
+      "- control.complete_task with nodeId completes a waiting_llm inline_llm task for the current Graph owner. control.complete_task with taskRunId is reserved for the owning TaskLoop. Do not directly complete expand or aggregate tasks.",
+      "- While Plan Mode is ON, workspace mutations must be represented as plan_graph tool nodes or performed inside a running task_loop.",
+      "- Treat a User reminder as the latest user instruction. Reconcile it before continuing from tool results. If it is compatible with the active plan, resume the waiting plan node; otherwise patch, cancel, or replan first.",
+      "- Use execution.kind=task_loop for work that should continue asynchronously without occupying the Agent Loop. plan_graph operation=control action=start_task starts the TaskRun and returns immediately.",
+      "- TaskLoops do not consume User reminders. The Agent Loop is woken by runtime task_started, task_succeeded, task_failed, and task_cancelled events.",
+      "- Runtime enforces TaskRun concurrency limits and workspace write leases. Direct Agent write, edit, or bash calls may be rejected while writing TaskRuns are active.",
+      "- Tool results may contain an artifactId. Use artifact_read to hydrate raw stored output or a slice of it; use read for workspace file paths.",
+      "- Use ask_user only when user input is required to proceed. It must be the only tool call in the turn. Use kind=approval for yes/no confirmation, kind=choice for numbered options, and kind=chat for free text.",
+      "- The answer to ask_user is returned only as that tool's result, not as a separate user message or pending User reminder. Continue from the returned answer and do not repeat the question.",
+      "- ask_user is available only to the Agent Loop. It pauses the Agent Loop, but running TaskRuns continue unless explicitly cancelled.",
+      "- Prefer structured argument references when passing upstream node outputs or artifacts into downstream tool arguments. Use string templates only when string interpolation is required, and reference only existing upstream nodes.",
+      "State commit schema (optional at segment end):",
+      '{"stateCommit":{"factsAdd":[],"hypothesesUpdate":[],"decisionsAdd":[],"questionsClose":[],"nextObjective":""},"contextPlan":{"retainRaw":[],"retainRegions":[],"summarize":[],"evict":[],"rehydrateNext":[]}}',
+    ].join("\n"),
+  ].join("\n\n");
+}
+
+function buildSkillCatalogVersion(skills = []) {
+  const names = (Array.isArray(skills) ? skills : [])
+    .map((s) => `${s.name}:${s.path}`)
+    .sort()
+    .join("|");
+  return hashContent(names || "empty");
+}
+
+function buildSessionStablePrefix({
+  workspaceRoot = "",
+  provider = "",
+  model = "",
+  sessionStableExtras = "",
+} = {}) {
+  const root = workspaceRoot || process.cwd();
+  const outcome = listUcodeSkills({ workspaceRoot: root });
+  const catalogVersion = buildSkillCatalogVersion(outcome.skills);
+  const parts = [
+    getUfooIntegrationSection(),
+    getSessionStableEnvironmentSection({ workspaceRoot: root, provider, model }),
+    renderSkillsSection(outcome.skills),
+    `skillCatalogVersion: ${catalogVersion}`,
+  ];
+  if (sessionStableExtras) parts.push(String(sessionStableExtras).trim());
+  return parts.filter(Boolean).join("\n\n");
+}
+
+function buildLayeredSystemPrompt({
+  workspaceRoot = "",
+  model = "",
+  provider = "",
+  appendSystemPrompt = "",
+  overrideSystemPrompt = "",
+  epochDynamic = "",
+  turnDynamic = "",
+  sessionStableExtras = "",
+} = {}) {
+  if (overrideSystemPrompt) {
+    return {
+      blocks: [{ layer: "override", text: overrideSystemPrompt, cacheable: false }],
+      flatText: overrideSystemPrompt,
+    };
+  }
+
+  const immutable = buildImmutablePrefix();
+  const sessionStable = buildSessionStablePrefix({
+    workspaceRoot,
+    provider,
+    model,
+    sessionStableExtras,
+  });
+  const epochText = String(epochDynamic || "").trim();
+  const turnParts = [
+    getTurnDynamicEnvironmentSection({ workspaceRoot: workspaceRoot || process.cwd() }),
+    String(turnDynamic || "").trim(),
+    String(appendSystemPrompt || "").trim(),
+  ].filter(Boolean);
+
+  const blocks = [
+    { layer: "immutable", text: immutable, cacheable: true },
+    { layer: "sessionStable", text: sessionStable, cacheable: true },
+  ];
+  if (epochText) {
+    blocks.push({
+      layer: "epoch",
+      text: epochText,
+      cacheable: true,
+    });
+  }
+  if (turnParts.length > 0) {
+    blocks.push({
+      layer: "turnDynamic",
+      text: turnParts.join("\n\n"),
+      cacheable: false,
+    });
+  }
+
+  return {
+    blocks,
+    flatText: blocks.map((b) => b.text).filter(Boolean).join("\n\n"),
+  };
+}
+
+function systemBlocksToAnthropicPayload(blocks = []) {
+  const list = (Array.isArray(blocks) ? blocks : []).filter((b) => b && b.text);
+  const ANTHROPIC_CACHE_CONTROL = { type: "ephemeral" };
+  // Place cache breakpoints on every cacheable layer so Anthropic can reuse
+  // Immutable → SessionStable → Epoch prefixes independently. Turn-dynamic
+  // never gets cache_control.
+  return list.map((block) => {
+    const entry = { type: "text", text: block.text };
+    if (block.cacheable) entry.cache_control = { ...ANTHROPIC_CACHE_CONTROL };
+    return entry;
+  });
+}
+
+module.exports = {
+  PROMPT_VERSION,
+  buildImmutablePrefix,
+  buildSessionStablePrefix,
+  buildLayeredSystemPrompt,
+  systemBlocksToAnthropicPayload,
+};

package/src/code/context/reducers.js

@@ -0,0 +1,328 @@
+"use strict";
+
+const PREVIEW_MAX_CHARS = 600;
+const MODEL_PAYLOAD_MAX_CHARS = 4000;
+
+function clipText(value = "", maxChars = PREVIEW_MAX_CHARS) {
+  const text = String(value || "");
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n...[truncated]`;
+}
+
+function tailLines(text = "", count = 20) {
+  const lines = String(text || "").split(/\r?\n/);
+  if (lines.length <= count) return lines.join("\n");
+  return lines.slice(-count).join("\n");
+}
+
+function isTestCommand(command = "", stdout = "") {
+  return /\b(npm test|pnpm test|yarn test|npx jest|jest|vitest|mocha|pytest|cargo test|go test)\b/i.test(command)
+    || /\b\d+\s+(passed|failed)\b/i.test(stdout)
+    || /FAIL|PASS|Tests:/i.test(stdout);
+}
+
+function isGitDiffCommand(command = "") {
+  return /\bgit\s+(?:diff|show)\b/i.test(String(command || ""));
+}
+
+function isSearchCommand(command = "") {
+  return /\b(rg|ripgrep|grep|ag|ack)\b/i.test(String(command || ""));
+}
+
+function extractTestFailures(stdout = "", stderr = "") {
+  const text = `${stdout}\n${stderr}`;
+  const failures = [];
+  const patterns = [
+    /●\s+([^\n]+)/g,
+    /FAIL\s+([^\n]+)/g,
+    /(?:AssertionError|Error):\s*([^\n]+)/g,
+    /FAILED\s+([^\n]+)/g,
+  ];
+  for (const re of patterns) {
+    let match;
+    while ((match = re.exec(text))) {
+      const title = String(match[1] || "").trim();
+      if (!title || failures.some((item) => item.title === title)) continue;
+      failures.push({ title: title.slice(0, 240) });
+      if (failures.length >= 12) return failures;
+    }
+  }
+  return failures;
+}
+
+function parseGitDiffFiles(stdout = "") {
+  const files = [];
+  const lines = String(stdout || "").split(/\r?\n/);
+  for (const line of lines) {
+    const diffMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (diffMatch) {
+      const pathText = String(diffMatch[2] || diffMatch[1] || "").trim();
+      if (pathText && !files.includes(pathText)) files.push(pathText);
+      continue;
+    }
+    const statusMatch = line.match(/^[AMD]\t(.+)$/);
+    if (statusMatch) {
+      const pathText = String(statusMatch[1] || "").trim();
+      if (pathText && !files.includes(pathText)) files.push(pathText);
+    }
+  }
+  return files.slice(0, 80);
+}
+
+function parseSearchMatches(stdout = "") {
+  const matches = [];
+  const lines = String(stdout || "").split(/\r?\n/).filter(Boolean);
+  for (const line of lines) {
+    const match = line.match(/^([^:]+):(\d+)(?::(\d+))?:(.*)$/);
+    if (!match) continue;
+    matches.push({
+      path: match[1],
+      line: Number(match[2]),
+      column: match[3] ? Number(match[3]) : undefined,
+      text: String(match[4] || "").trim().slice(0, 200),
+    });
+    if (matches.length >= 40) break;
+  }
+  return matches;
+}
+
+function reduceReadResult(raw = {}, artifactId = "") {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const content = String(source.content || "");
+  const preview = clipText(content, PREVIEW_MAX_CHARS);
+  const modelPayload = {
+    ok: source.ok !== false,
+    artifactId,
+    path: source.path || "",
+    startLine: source.startLine,
+    endLine: source.endLine,
+    totalLines: source.totalLines,
+    truncated: Boolean(source.truncated),
+    fileHash: source.fileHash || "",
+    preview,
+  };
+  if (content && content.length <= MODEL_PAYLOAD_MAX_CHARS) {
+    modelPayload.content = content;
+  } else if (content) {
+    modelPayload.content = clipText(content, MODEL_PAYLOAD_MAX_CHARS);
+    modelPayload.contentTruncated = true;
+  }
+  if (source.error) modelPayload.error = String(source.error);
+  return {
+    preview,
+    summary: `read ${source.path || "file"} (${source.totalLines || "?"} lines)`,
+    modelPayload,
+  };
+}
+
+function reduceTestResult(raw = {}, artifactId = "", args = {}) {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const stdout = String(source.stdout || "");
+  const stderr = String(source.stderr || "");
+  const failedMatch = stdout.match(/(\d+)\s+failed/i) || stderr.match(/(\d+)\s+failed/i);
+  const passedMatch = stdout.match(/(\d+)\s+passed/i) || stderr.match(/(\d+)\s+passed/i);
+  const failures = extractTestFailures(stdout, stderr);
+  const preview = clipText(
+    [stdout ? `stdout:\n${tailLines(stdout, 12)}` : "", stderr ? `stderr:\n${tailLines(stderr, 8)}` : ""]
+      .filter(Boolean)
+      .join("\n"),
+    PREVIEW_MAX_CHARS,
+  );
+  return {
+    preview,
+    summary: `test exit=${source.code ?? source.exitCode ?? "?"} failed=${failedMatch ? failedMatch[1] : failures.length}`,
+    modelPayload: {
+      ok: source.ok !== false,
+      artifactId,
+      kind: "test",
+      exitCode: source.code ?? source.exitCode ?? null,
+      passed: passedMatch ? Number(passedMatch[1]) : undefined,
+      failed: failedMatch ? Number(failedMatch[1]) : failures.length || undefined,
+      failures,
+      stdoutTail: tailLines(stdout, 24),
+      stderrTail: tailLines(stderr, 12),
+      error: source.error ? String(source.error) : undefined,
+    },
+  };
+}
+
+function reduceGitDiffResult(raw = {}, artifactId = "", args = {}) {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const stdout = String(source.stdout || "");
+  const files = parseGitDiffFiles(stdout);
+  const preview = clipText(
+    files.length > 0
+      ? `git diff files (${files.length}):\n${files.slice(0, 20).join("\n")}`
+      : tailLines(stdout, 20),
+    PREVIEW_MAX_CHARS,
+  );
+  return {
+    preview,
+    summary: `git diff files=${files.length}`,
+    modelPayload: {
+      ok: source.ok !== false,
+      artifactId,
+      kind: "git_diff",
+      exitCode: source.code ?? source.exitCode ?? null,
+      files,
+      // Current diff stays complete in artifact; model gets file list + short preview.
+      stdoutTail: tailLines(stdout, 40),
+      stderrTail: tailLines(String(source.stderr || ""), 8),
+      error: source.error ? String(source.error) : undefined,
+    },
+  };
+}
+
+function reduceSearchResult(raw = {}, artifactId = "", args = {}) {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const stdout = String(source.stdout || "");
+  const matches = parseSearchMatches(stdout);
+  const preview = clipText(
+    matches.length > 0
+      ? matches.slice(0, 12).map((m) => `${m.path}:${m.line}: ${m.text}`).join("\n")
+      : tailLines(stdout, 20),
+    PREVIEW_MAX_CHARS,
+  );
+  return {
+    preview,
+    summary: `search matches=${matches.length}`,
+    modelPayload: {
+      ok: source.ok !== false,
+      artifactId,
+      kind: "search",
+      exitCode: source.code ?? source.exitCode ?? null,
+      matchCount: matches.length,
+      matches,
+      stdoutTail: tailLines(stdout, 20),
+      stderrTail: tailLines(String(source.stderr || ""), 8),
+      error: source.error ? String(source.error) : undefined,
+    },
+  };
+}
+
+function reduceBashResult(raw = {}, artifactId = "", args = {}) {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const stdout = String(source.stdout || "");
+  const stderr = String(source.stderr || "");
+  const command = String((args && args.command) || source.command || "");
+
+  if (isTestCommand(command, stdout)) {
+    return reduceTestResult(raw, artifactId, args);
+  }
+  if (isGitDiffCommand(command)) {
+    return reduceGitDiffResult(raw, artifactId, args);
+  }
+  if (isSearchCommand(command)) {
+    return reduceSearchResult(raw, artifactId, args);
+  }
+
+  const preview = clipText(
+    [stdout ? `stdout:\n${tailLines(stdout, 8)}` : "", stderr ? `stderr:\n${tailLines(stderr, 8)}` : ""]
+      .filter(Boolean)
+      .join("\n"),
+    PREVIEW_MAX_CHARS,
+  );
+  return {
+    preview,
+    summary: `bash exit=${source.code ?? source.exitCode ?? "?"}`,
+    modelPayload: {
+      ok: source.ok !== false,
+      artifactId,
+      exitCode: source.code ?? source.exitCode ?? null,
+      stdoutTail: tailLines(stdout, 20),
+      stderrTail: tailLines(stderr, 20),
+      error: source.error ? String(source.error) : undefined,
+    },
+  };
+}
+
+function reduceWriteResult(raw = {}, artifactId = "") {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const preview = `write ${source.path || "file"} (${source.bytes || 0} bytes)`;
+  return {
+    preview,
+    summary: preview,
+    modelPayload: {
+      ok: source.ok !== false,
+      artifactId,
+      path: source.path || "",
+      mode: source.mode,
+      bytes: source.bytes,
+      error: source.error ? String(source.error) : undefined,
+    },
+  };
+}
+
+function reduceEditResult(raw = {}, artifactId = "") {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const preview = `edit ${source.path || "file"} changed=${Boolean(source.changed)}`;
+  return {
+    preview,
+    summary: preview,
+    modelPayload: {
+      ok: source.ok !== false,
+      artifactId,
+      path: source.path || "",
+      changed: Boolean(source.changed),
+      replacements: source.replacements,
+      error: source.error ? String(source.error) : undefined,
+    },
+  };
+}
+
+function reduceArtifactReadResult(raw = {}, artifactId = "") {
+  const source = raw && typeof raw === "object" ? raw : {};
+  const content = String(source.content || "");
+  return {
+    preview: clipText(content, PREVIEW_MAX_CHARS),
+    summary: `artifact_read ${source.artifactId || artifactId}`,
+    modelPayload: {
+      ok: source.ok !== false,
+      artifactId: source.artifactId || artifactId,
+      content: clipText(content, MODEL_PAYLOAD_MAX_CHARS),
+      range: source.range,
+      truncated: Boolean(source.truncated),
+      error: source.error ? String(source.error) : undefined,
+    },
+  };
+}
+
+function reduceToolResult(tool = "", raw = {}, artifactId = "", args = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  if (name === "read") return reduceReadResult(raw, artifactId);
+  if (name === "bash") return reduceBashResult(raw, artifactId, args);
+  if (name === "write") return reduceWriteResult(raw, artifactId);
+  if (name === "edit") return reduceEditResult(raw, artifactId);
+  if (name === "artifact_read") return reduceArtifactReadResult(raw, artifactId);
+  const text = typeof raw === "string" ? raw : JSON.stringify(raw);
+  return {
+    preview: clipText(text, PREVIEW_MAX_CHARS),
+    summary: `${name || "tool"} result`,
+    modelPayload: {
+      ok: raw && raw.ok !== false,
+      artifactId,
+      preview: clipText(text, MODEL_PAYLOAD_MAX_CHARS),
+    },
+  };
+}
+
+module.exports = {
+  PREVIEW_MAX_CHARS,
+  MODEL_PAYLOAD_MAX_CHARS,
+  clipText,
+  isTestCommand,
+  isGitDiffCommand,
+  isSearchCommand,
+  extractTestFailures,
+  parseGitDiffFiles,
+  parseSearchMatches,
+  reduceToolResult,
+  reduceReadResult,
+  reduceBashResult,
+  reduceTestResult,
+  reduceGitDiffResult,
+  reduceSearchResult,
+  reduceWriteResult,
+  reduceEditResult,
+  reduceArtifactReadResult,
+};

package/src/code/context/stableJson.js

@@ -0,0 +1,29 @@
+"use strict";
+
+function stableValue(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item) => stableValue(item));
+  const keys = Object.keys(value).sort();
+  const out = {};
+  for (const key of keys) {
+    out[key] = stableValue(value[key]);
+  }
+  return out;
+}
+
+function stableStringify(value) {
+  try {
+    return JSON.stringify(stableValue(value));
+  } catch {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value || "");
+    }
+  }
+}
+
+module.exports = {
+  stableValue,
+  stableStringify,
+};