u-foo 2.5.13 → 2.5.15

package/src/code/context/executionSegment.js

@@ -0,0 +1,314 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+
+function emptyExecutionState() {
+  return {
+    currentSegmentId: "",
+    mode: "single_action",
+    steps: {},
+    modifiedFiles: [],
+    lastExitCodes: [],
+    approvals: [],
+    retries: {},
+    segments: [],
+  };
+}
+
+function createSegmentId() {
+  return `seg_${Date.now().toString(36)}_${randomUUID().slice(0, 6)}`;
+}
+
+function normalizeExecutionSegment(segment = {}) {
+  const source = segment && typeof segment === "object" ? segment : {};
+  const steps = Array.isArray(source.steps) ? source.steps : [];
+  return {
+    type: String(source.type || "execution_segment").trim(),
+    objective: String(source.objective || "").trim(),
+    steps: steps.map((step, index) => ({
+      id: String(step.id || `s${index + 1}`).trim(),
+      tool: String(step.tool || "").trim(),
+      args: step.args && typeof step.args === "object" ? step.args : {},
+      dependsOn: Array.isArray(step.dependsOn) ? step.dependsOn.map(String) : [],
+    })),
+    checkpoint: source.checkpoint && typeof source.checkpoint === "object"
+      ? source.checkpoint
+      : { after: [] },
+  };
+}
+
+function startExecutionSegment(executionState = null, segment = {}) {
+  const state = executionState && typeof executionState === "object"
+    ? { ...executionState }
+    : emptyExecutionState();
+  const normalized = normalizeExecutionSegment(segment);
+  const segmentId = createSegmentId();
+  state.currentSegmentId = segmentId;
+  state.mode = normalized.type === "execution_segment" ? "execution_segment" : "single_action";
+  state.segments = Array.isArray(state.segments) ? state.segments : [];
+  state.segments.push({
+    segmentId,
+    objective: normalized.objective,
+    startedAt: new Date().toISOString(),
+    steps: normalized.steps,
+    checkpoint: normalized.checkpoint,
+    status: "running",
+  });
+  state.steps = {};
+  return { state, segmentId, segment: normalized };
+}
+
+function recordStepResult(executionState = null, {
+  stepId = "",
+  status = "success",
+  artifactId = "",
+  exitCode = null,
+  error = "",
+} = {}) {
+  const state = executionState && typeof executionState === "object"
+    ? { ...executionState }
+    : emptyExecutionState();
+  state.steps = state.steps && typeof state.steps === "object" ? { ...state.steps } : {};
+  state.steps[stepId] = {
+    status: String(status || "success"),
+    artifactId: String(artifactId || ""),
+    exitCode,
+    error: String(error || ""),
+    at: new Date().toISOString(),
+  };
+  return state;
+}
+
+function shouldStopSegment(executionState = null, {
+  hadError = false,
+  schemaMismatch = false,
+  sideEffect = false,
+  reachedCheckpoint = false,
+} = {}) {
+  if (hadError || schemaMismatch || sideEffect) return true;
+  if (reachedCheckpoint) return true;
+  const state = executionState && typeof executionState === "object" ? executionState : null;
+  if (!state || state.mode !== "execution_segment") return true;
+  return false;
+}
+
+function renderExecutionSegmentContext(executionState = null) {
+  if (!executionState || !executionState.currentSegmentId) return "";
+  const lines = [
+    "Current Execution Segment:",
+    `- Segment: ${executionState.currentSegmentId}`,
+    `- Mode: ${executionState.mode || "single_action"}`,
+  ];
+  const steps = executionState.steps && typeof executionState.steps === "object"
+    ? Object.entries(executionState.steps)
+    : [];
+  if (steps.length > 0) {
+    lines.push("Step status:");
+    for (const [id, info] of steps) {
+      lines.push(`- ${id}: ${info.status}${info.error ? ` (${info.error})` : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function parseExecutionSegment(sideEffects = null) {
+  if (!sideEffects || typeof sideEffects !== "object") return null;
+  if (sideEffects.nextSegment) return normalizeExecutionSegment(sideEffects.nextSegment);
+  if (sideEffects.type === "execution_segment") return normalizeExecutionSegment(sideEffects);
+  return null;
+}
+
+const DEFAULT_MAX_SEGMENT_STEPS = 4;
+const SIDE_EFFECT_TOOLS = new Set(["write", "edit"]);
+
+function resolveStepArgs(args = {}, stepOutputs = new Map()) {
+  const next = args && typeof args === "object" ? { ...args } : {};
+  const argsJson = JSON.stringify(next);
+  for (const [depId, depValue] of stepOutputs.entries()) {
+    const token = `\${${depId}.matches}`;
+    if (argsJson.includes(token) && depValue && depValue.matches) {
+      next.matches = depValue.matches;
+    }
+  }
+  return next;
+}
+
+function isSideEffectTool(tool = "") {
+  return SIDE_EFFECT_TOOLS.has(String(tool || "").trim().toLowerCase());
+}
+
+function formatSegmentResultMessage(result = {}) {
+  return JSON.stringify({
+    type: "execution_segment_result",
+    segmentId: result.segmentId || "",
+    ok: result.ok !== false,
+    objective: result.objective || "",
+    stoppedAt: result.stoppedAt || "",
+    steps: Array.isArray(result.results) ? result.results : [],
+    error: result.error || "",
+  });
+}
+
+function executeExecutionSegment({
+  segment = {},
+  executionState = null,
+  runStep = () => ({ ok: false, error: "no runner" }),
+  onStepStart = null,
+  onStepComplete = null,
+  maxSteps = DEFAULT_MAX_SEGMENT_STEPS,
+} = {}) {
+  const normalized = normalizeExecutionSegment(segment);
+  const cappedSteps = normalized.steps.slice(0, Math.max(1, Math.floor(maxSteps)));
+  const cappedSegment = { ...normalized, steps: cappedSteps };
+  const { state: startedState, segmentId } = startExecutionSegment(executionState, cappedSegment);
+  let state = startedState;
+  const stepOutputs = new Map();
+  const results = [];
+  const checkpointAfter = new Set(
+    Array.isArray(cappedSegment.checkpoint && cappedSegment.checkpoint.after)
+      ? cappedSegment.checkpoint.after.map(String)
+      : [],
+  );
+  let stoppedAt = "";
+  let fatalError = "";
+
+  for (const step of cappedSteps) {
+    const deps = Array.isArray(step.dependsOn) ? step.dependsOn : [];
+    for (const dep of deps) {
+      if (!stepOutputs.has(dep)) {
+        state = recordStepResult(state, {
+          stepId: step.id,
+          status: "failed",
+          error: `missing dependency ${dep}`,
+        });
+        fatalError = `segment dependency missing: ${dep}`;
+        state = completeExecutionSegment(state, { status: "failed", error: fatalError });
+        return {
+          ok: false,
+          segmentId,
+          objective: cappedSegment.objective,
+          executionState: state,
+          results,
+          error: fatalError,
+          stoppedAt: "dependency",
+        };
+      }
+    }
+
+    const args = resolveStepArgs(step.args, stepOutputs);
+    if (typeof onStepStart === "function") {
+      try {
+        onStepStart({ stepId: step.id, tool: step.tool, args });
+      } catch {
+        // ignore
+      }
+    }
+
+    const result = runStep({ stepId: step.id, tool: step.tool, args }) || { ok: false, error: "step failed" };
+    const stepRecord = {
+      stepId: step.id,
+      tool: step.tool,
+      ok: result.ok !== false,
+      artifactId: result.artifactId || "",
+      error: result.error || "",
+    };
+    results.push(stepRecord);
+
+    if (result.ok === false) {
+      state = recordStepResult(state, {
+        stepId: step.id,
+        status: "failed",
+        error: String(result.error || "step failed"),
+      });
+      fatalError = String(result.error || "segment step failed");
+      state = completeExecutionSegment(state, { status: "failed", error: fatalError });
+      return {
+        ok: false,
+        segmentId,
+        objective: cappedSegment.objective,
+        executionState: state,
+        results,
+        error: fatalError,
+        stoppedAt: "error",
+      };
+    }
+
+    stepOutputs.set(step.id, result);
+    state = recordStepResult(state, {
+      stepId: step.id,
+      status: "success",
+      artifactId: result.artifactId || "",
+      exitCode: Number.isFinite(result.code) ? result.code : null,
+    });
+
+    if (typeof onStepComplete === "function") {
+      try {
+        onStepComplete({ stepId: step.id, tool: step.tool, args, result });
+      } catch {
+        // ignore
+      }
+    }
+
+    if (checkpointAfter.has(step.id)) {
+      stoppedAt = "checkpoint";
+      break;
+    }
+    if (isSideEffectTool(step.tool)) {
+      stoppedAt = "side_effect";
+      break;
+    }
+  }
+
+  const finalStatus = stoppedAt === "checkpoint" ? "checkpoint" : "success";
+  state = completeExecutionSegment(state, { status: finalStatus });
+  return {
+    ok: true,
+    segmentId,
+    objective: cappedSegment.objective,
+    executionState: state,
+    results,
+    error: "",
+    stoppedAt,
+  };
+}
+
+function completeExecutionSegment(executionState = null, { status = "success", error = "" } = {}) {
+  const state = executionState && typeof executionState === "object"
+    ? { ...executionState }
+    : emptyExecutionState();
+  const segments = Array.isArray(state.segments) ? state.segments.slice() : [];
+  const currentId = String(state.currentSegmentId || "").trim();
+  if (currentId) {
+    for (let i = segments.length - 1; i >= 0; i -= 1) {
+      if (segments[i].segmentId === currentId) {
+        segments[i] = {
+          ...segments[i],
+          status,
+          error: String(error || ""),
+          endedAt: new Date().toISOString(),
+        };
+        break;
+      }
+    }
+  }
+  state.segments = segments;
+  state.currentSegmentId = "";
+  state.mode = "single_action";
+  return state;
+}
+
+module.exports = {
+  DEFAULT_MAX_SEGMENT_STEPS,
+  emptyExecutionState,
+  createSegmentId,
+  normalizeExecutionSegment,
+  startExecutionSegment,
+  recordStepResult,
+  shouldStopSegment,
+  renderExecutionSegmentContext,
+  parseExecutionSegment,
+  completeExecutionSegment,
+  executeExecutionSegment,
+  formatSegmentResultMessage,
+  isSideEffectTool,
+};

package/src/code/context/featureFlag.js

@@ -0,0 +1,13 @@
+"use strict";
+
+function isContextV2Enabled(env = process.env) {
+  const raw = String(env.UFOO_UCODE_CONTEXT_V2 || "").trim().toLowerCase();
+  // Default ON. Explicit opt-out: 0 / false / off / no.
+  if (!raw) return true;
+  if (raw === "0" || raw === "false" || raw === "off" || raw === "no") return false;
+  return raw === "1" || raw === "true" || raw === "on" || raw === "yes";
+}
+
+module.exports = {
+  isContextV2Enabled,
+};

package/src/code/context/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+module.exports = {
+  ...require("./featureFlag"),
+  ...require("./transcript"),
+  ...require("./transcriptSync"),
+  ...require("./artifacts"),
+  ...require("./artifactIndex"),
+  ...require("./artifactGc"),
+  ...require("./stableJson"),
+  ...require("./reducers"),
+  ...require("./promptLayers"),
+  ...require("./projectSnapshot"),
+  ...require("./stateCommit"),
+  ...require("./workingSet"),
+  ...require("./executionSegment"),
+  ...require("./assembler"),
+};

package/src/code/context/projectSnapshot.js

@@ -0,0 +1,201 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { runToolCall } = require("../dispatch");
+const { saveArtifact, createArtifactId, hashContent } = require("./artifacts");
+
+const PREFLIGHT_FILES = [
+  "AGENTS.md",
+  "README.md",
+  "README.zh-CN.md",
+  "package.json",
+];
+
+function readFileIfExists(workspaceRoot = process.cwd(), relPath = "") {
+  const full = path.resolve(workspaceRoot, relPath);
+  try {
+    if (!fs.existsSync(full) || !fs.statSync(full).isFile()) return null;
+    const content = fs.readFileSync(full, "utf8");
+    return { path: relPath, content, hash: hashContent(content) };
+  } catch {
+    return null;
+  }
+}
+
+function summarizePackageJson(content = "") {
+  try {
+    const parsed = JSON.parse(content);
+    return {
+      name: parsed.name || "",
+      packageManager: parsed.packageManager || "",
+      scripts: Object.keys(parsed.scripts || {}).slice(0, 8),
+    };
+  } catch {
+    return {};
+  }
+}
+
+function summarizeAgentsRules(content = "") {
+  const lines = String(content || "").split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  return lines.slice(0, 12);
+}
+
+function summarizeReadme(content = "") {
+  const lines = String(content || "").split(/\r?\n/);
+  const headings = lines
+    .filter((l) => /^#{1,3}\s+/.test(l))
+    .slice(0, 10);
+  const intro = lines.filter((l) => l.trim() && !l.startsWith("#")).slice(0, 3).join(" ");
+  return { headings, intro: intro.slice(0, 240) };
+}
+
+function collectCurrentFileHashes(workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot || process.cwd());
+  return PREFLIGHT_FILES.map((relPath) => {
+    const file = readFileIfExists(root, relPath);
+    return file ? { path: relPath, hash: file.hash } : null;
+  }).filter(Boolean);
+}
+
+function isProjectSnapshotStale(snapshot = null, workspaceRoot = process.cwd()) {
+  if (!snapshot || !snapshot.projectSnapshotId || !Array.isArray(snapshot.files)) return true;
+  const current = collectCurrentFileHashes(workspaceRoot);
+  if (current.length !== snapshot.files.length) return true;
+  const byPath = new Map(snapshot.files.map((entry) => [entry.path, entry.hash]));
+  for (const entry of current) {
+    if (byPath.get(entry.path) !== entry.hash) return true;
+  }
+  return false;
+}
+
+function invalidateProjectSnapshotIfPathTouched(session = {}, filePath = "") {
+  if (!session || typeof session !== "object") return false;
+  const rel = String(filePath || "").trim().replace(/\\/g, "/");
+  if (!rel) return false;
+  const touched = PREFLIGHT_FILES.some((name) => (
+    rel === name || rel.endsWith(`/${name}`)
+  ));
+  if (!touched) return false;
+  session.projectSnapshot = null;
+  return true;
+}
+
+function buildProjectSnapshot({
+  workspaceRoot = process.cwd(),
+  sessionId = "",
+  existing = null,
+} = {}) {
+  const root = path.resolve(workspaceRoot || process.cwd());
+  if (existing && !isProjectSnapshotStale(existing, root)) {
+    return existing;
+  }
+  const files = [];
+  const summary = {
+    language: "",
+    packageManager: "",
+    entryPoints: [],
+    rules: [],
+    readmeHeadings: [],
+    readmeIntro: "",
+  };
+
+  for (const relPath of PREFLIGHT_FILES) {
+    const file = readFileIfExists(root, relPath);
+    if (!file) continue;
+    const artifactId = createArtifactId(`artifact_${relPath.replace(/[^a-zA-Z0-9]+/g, "_")}`);
+    saveArtifact(root, sessionId, {
+      artifactId,
+      type: "source_file",
+      source: relPath,
+      tool: "read",
+      raw: { ok: true, path: relPath, content: file.content },
+      summary: relPath,
+      createdBy: "project_snapshot",
+    });
+    files.push({
+      path: relPath,
+      artifactId,
+      hash: file.hash,
+    });
+    if (relPath === "package.json") {
+      const pkg = summarizePackageJson(file.content);
+      summary.packageManager = pkg.packageManager || "";
+      summary.language = "Node.js";
+      summary.entryPoints = pkg.scripts || [];
+    }
+    if (relPath === "AGENTS.md") {
+      summary.rules = summarizeAgentsRules(file.content);
+    }
+    if (relPath.startsWith("README")) {
+      const readme = summarizeReadme(file.content);
+      summary.readmeHeadings = readme.headings;
+      summary.readmeIntro = readme.intro;
+    }
+  }
+
+  const snapshotId = `project_snapshot_${hashContent(JSON.stringify(files))}`;
+
+  return {
+    projectSnapshotId: snapshotId,
+    files,
+    summary,
+    createdAt: new Date().toISOString(),
+  };
+}
+
+function renderProjectSnapshotContext(snapshot = null) {
+  if (!snapshot || !snapshot.projectSnapshotId) return "";
+  const summary = snapshot.summary && typeof snapshot.summary === "object" ? snapshot.summary : {};
+  const fileRefs = (Array.isArray(snapshot.files) ? snapshot.files : [])
+    .map((f) => `- ${f.path}: artifact://${f.artifactId} (hash ${f.hash})`)
+    .join("\n");
+  const lines = [
+    "Project Snapshot:",
+    summary.language ? `- Language: ${summary.language}` : "",
+    summary.packageManager ? `- Package manager: ${summary.packageManager}` : "",
+    summary.rules && summary.rules.length > 0
+      ? `- Repository rules: ${summary.rules.slice(0, 5).join("; ")}`
+      : "",
+    summary.readmeIntro ? `- README intro: ${summary.readmeIntro}` : "",
+    fileRefs ? `Files:\n${fileRefs}` : "",
+  ].filter(Boolean);
+  return lines.join("\n");
+}
+
+function createProjectPreflightContextV2({
+  workspaceRoot = process.cwd(),
+  sessionId = "",
+  pushToolLog = () => null,
+  existingSnapshot = null,
+} = {}) {
+  const root = String(workspaceRoot || process.cwd());
+  for (const relPath of PREFLIGHT_FILES) {
+    pushToolLog({ tool: "read", phase: "start", args: { path: relPath }, error: "" });
+    const readRes = runToolCall(
+      { tool: "read", args: { path: relPath, maxBytes: 12000 } },
+      { workspaceRoot: root, cwd: root },
+    );
+    pushToolLog({
+      tool: "read",
+      phase: readRes && readRes.ok === false ? "error" : "",
+      args: { path: relPath },
+      error: readRes && readRes.ok === false ? String(readRes.error || "") : "",
+    });
+  }
+  return buildProjectSnapshot({
+    workspaceRoot: root,
+    sessionId,
+    existing: existingSnapshot,
+  });
+}
+
+module.exports = {
+  PREFLIGHT_FILES,
+  buildProjectSnapshot,
+  renderProjectSnapshotContext,
+  createProjectPreflightContextV2,
+  isProjectSnapshotStale,
+  invalidateProjectSnapshotIfPathTouched,
+  collectCurrentFileHashes,
+};

package/src/code/context/promptLayers.js

@@ -0,0 +1,159 @@
+"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-v4";
+
+function buildImmutablePrefix() {
+  return [
+    `promptVersion: ${PROMPT_VERSION}`,
+    getIdentitySection(),
+    getSystemSection(),
+    getDoingTasksSection(),
+    getActionsSection(),
+    getSafetySection(),
+    getOutputEfficiencySection(),
+    [
+      "Tool calling grammar:",
+      "- Use read, write, edit, bash, artifact_read tools.",
+      "- Tool results may reference artifactId; use artifact_read to hydrate raw content.",
+      "State commit schema (optional at segment end):",
+      '{"stateCommit":{"factsAdd":[],"hypothesesUpdate":[],"decisionsAdd":[],"questionsClose":[],"nextObjective":""},"contextPlan":{"retainRaw":[],"retainRegions":[],"summarize":[],"evict":[],"rehydrateNext":[]}}',
+      "Context action schema:",
+      '{"type":"execution_segment","objective":"","steps":[],"checkpoint":{"after":[]}}',
+    ].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,
+};