u-foo 3.0.6 → 3.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "3.0.6",
+  "version": "3.0.7",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/code/agent.js

@@ -610,6 +610,21 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
     : runNativeAgentTask;
   const onPhase = typeof options.onPhase === "function" ? options.onPhase : null;
   const onThinkingDelta = typeof options.onThinkingDelta === "function" ? options.onThinkingDelta : null;
+  const onContextUsage = typeof options.onContextUsage === "function" ? options.onContextUsage : null;
+  const applyContextMeter = (meter = null) => {
+    if (!meter || typeof meter !== "object") return null;
+    state.contextMeter = {
+      usedTokens: Number(meter.usedTokens) || 0,
+      limitTokens: Number(meter.limitTokens) || 0,
+      model: String(meter.model || state.model || "").trim(),
+      label: String(meter.label || "").trim(),
+      updatedAt: String(meter.updatedAt || "").trim() || new Date().toISOString(),
+    };
+    if (typeof onContextUsage === "function") {
+      try { onContextUsage(state.contextMeter); } catch { /* ignore */ }
+    }
+    return state.contextMeter;
+  };
   let lastTranscriptBaseline = 0;
   const invokeNative = (sessionIdValue = "", timeoutOverrideMs = timeoutMs) => {
     toolEventsThisAttempt = 0;
@@ -630,6 +645,7 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
       onStreamDelta: onStream,
       onThinkingDelta,
       onPhase,
+      onContextUsage: applyContextMeter,
       executionState: state.executionState || null,
       onArtifactPersisted: (persisted) => recordToolCallInSession(state, persisted, workspaceRoot),
       onToolEvent: (event) => {
@@ -779,6 +795,9 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
     const artifactIds = Array.isArray(state.workingSet)
       ? state.workingSet.map((entry) => entry.artifactId).filter(Boolean)
       : [];
+    if (cliRes && cliRes.contextMeter) {
+      applyContextMeter(cliRes.contextMeter);
+    }
     if (cliRes && cliRes.waitingUserInteraction) {
       return {
         ok: true,
@@ -791,6 +810,8 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
         streamLastChar,
         waitingUserInteraction: true,
         interactionId: cliRes.interactionId || "",
+        contextMeter: state.contextMeter || null,
+        usage: cliRes.usage || null,
       };
     }
     return {
@@ -802,6 +823,8 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
       metrics: {},
       streamed: Boolean(streamed || cliRes.streamed),
       streamLastChar,
+      contextMeter: state.contextMeter || null,
+      usage: cliRes.usage || null,
     };
   } catch (err) {
     return {
@@ -925,6 +948,9 @@ function buildSessionSnapshotFromState(state = {}) {
       ? Math.max(0, Math.floor(source.toolCallsSinceCommit))
       : 0,
     activeSkills: Array.isArray(source.activeSkills) ? source.activeSkills : [],
+    contextMeter: source.contextMeter && typeof source.contextMeter === "object"
+      ? source.contextMeter
+      : null,
   };
 }
 
@@ -999,6 +1025,9 @@ function resumeSessionState(state = {}, sessionId = "", workspaceRoot = process.
     ? snapshot.toolCallsSinceCommit
     : 0;
   state.activeSkills = Array.isArray(snapshot.activeSkills) ? snapshot.activeSkills : [];
+  state.contextMeter = snapshot.contextMeter && typeof snapshot.contextMeter === "object"
+    ? snapshot.contextMeter
+    : null;
   ensureContextSessionState(state);
   const { ensureTranscript } = require("./context/assembler");
   ensureTranscript(state, state.workspaceRoot);
@@ -1087,6 +1116,13 @@ async function resumeAfterUserInteraction(answerText = "", state = {}, options =
     onStreamDelta: trackingOnDelta,
     onThinkingDelta: typeof options.onThinkingDelta === "function" ? options.onThinkingDelta : null,
     onPhase: typeof options.onPhase === "function" ? options.onPhase : null,
+    onContextUsage: (meter) => {
+      if (!meter || typeof meter !== "object") return;
+      state.contextMeter = meter;
+      if (typeof options.onContextUsage === "function") {
+        try { options.onContextUsage(meter); } catch { /* ignore */ }
+      }
+    },
     executionState: state.executionState,
     signal: options.signal,
     resume: true,
@@ -1098,6 +1134,9 @@ async function resumeAfterUserInteraction(answerText = "", state = {}, options =
   if (cliRes && Array.isArray(cliRes.messages)) {
     state.nlMessages = stripSkillBlocksFromMessages(cliRes.messages);
   }
+  if (cliRes && cliRes.contextMeter) {
+    state.contextMeter = cliRes.contextMeter;
+  }
 
   if (!cliRes || cliRes.ok === false) {
     return {
@@ -1107,6 +1146,7 @@ async function resumeAfterUserInteraction(answerText = "", state = {}, options =
       waitingUserInteraction: false,
       streamed: false,
       streamLastChar: "",
+      contextMeter: state.contextMeter || null,
     };
   }
 
@@ -1119,6 +1159,7 @@ async function resumeAfterUserInteraction(answerText = "", state = {}, options =
       interactionId: cliRes.interactionId || "",
       streamed: Boolean(cliRes.streamed),
       streamLastChar,
+      contextMeter: state.contextMeter || null,
     };
   }
 
@@ -1129,6 +1170,7 @@ async function resumeAfterUserInteraction(answerText = "", state = {}, options =
     waitingUserInteraction: false,
     streamed: Boolean(cliRes.streamed),
     streamLastChar,
+    contextMeter: state.contextMeter || null,
   };
 }
 

package/src/code/context/planProjection.js

@@ -287,78 +287,94 @@ function buildPlanDag(planGraph = {}) {
   };
 }
 
-function waveStepLabel(waveIndex = 0, nodeIndex = 0, waveSize = 1) {
-  const step = Math.max(1, Math.floor(Number(waveIndex) || 0) + 1);
-  if (waveSize <= 1) return String(step);
-  const letter = String.fromCharCode(97 + Math.max(0, Math.min(25, Math.floor(Number(nodeIndex) || 0))));
-  return `${step}${letter}`;
+function countDagProgress(dag = {}) {
+  const nodes = Array.isArray(dag.nodes) ? dag.nodes : [];
+  const total = nodes.length;
+  const done = nodes.filter((node) => node && node.kind === "done").length;
+  return { done, total };
 }
 
-function formatParallelWaveLines(wave = [], waveIndex = 0, titleMax = 40) {
-  const lines = [];
-  const size = wave.length;
-  wave.forEach((node, nodeIndex) => {
-    const label = waveStepLabel(waveIndex, nodeIndex, size);
-    const body = `${label} ${node.mark} ${truncate(node.title, titleMax)}`;
-    if (nodeIndex === 0) {
-      lines.push(`  ┌─ ${body}`);
-      if (size > 1) lines.push("──┤");
-      return;
-    }
-    if (nodeIndex === size - 1) {
-      lines.push(`  └─ ${body}`);
-      return;
+function titleMaxForCols(cols = 80, reserved = 12) {
+  return Math.max(12, Math.min(48, Math.floor(Number(cols) || 80) - reserved));
+}
+
+function pickFocusActiveNodes(dag = {}) {
+  const nodes = Array.isArray(dag.nodes) ? dag.nodes : [];
+  const active = nodes.filter((node) => node && node.kind === "active");
+  if (active.length > 0) return active;
+
+  const waves = Array.isArray(dag.waves) ? dag.waves : [];
+  for (const wave of waves) {
+    const incomplete = (Array.isArray(wave) ? wave : []).filter((node) => (
+      node
+      && node.kind !== "done"
+      && node.kind !== "cancelled"
+    ));
+    if (incomplete.length === 0) continue;
+    const ready = incomplete.filter((node) => String(node.status || "").toLowerCase() === "ready");
+    return ready.length > 0 ? ready : incomplete.slice(0, 1);
+  }
+  return [];
+}
+
+function pickUpcomingNodes(dag = {}, activeIds = new Set(), limit = 2) {
+  const upcoming = [];
+  const waves = Array.isArray(dag.waves) ? dag.waves : [];
+  for (const wave of waves) {
+    for (const node of (Array.isArray(wave) ? wave : [])) {
+      if (!node || activeIds.has(node.id)) continue;
+      if (node.kind === "done" || node.kind === "cancelled") continue;
+      upcoming.push(node);
+      if (upcoming.length >= limit) return upcoming;
     }
-    lines.push(`  ├─ ${body}`);
-  });
-  return lines;
+    if (upcoming.length >= limit) break;
+  }
+  return upcoming;
+}
+
+function clipRoadmapLines(lines = [], maxRows = 10) {
+  const list = Array.isArray(lines) ? lines : [];
+  const limit = Number.isFinite(maxRows) && maxRows > 0 ? Math.floor(maxRows) : 10;
+  if (list.length <= limit) return list.slice();
+  const clipped = list.slice(0, Math.max(1, limit - 1));
+  clipped.push(`… +${list.length - clipped.length} more`);
+  return clipped;
 }
 
 /**
- * Build markdown (linear list) or ASCII flowchart (parallel waves) from planGraph JSON.
+ * Default auto band: progress + current task(s) + next titles.
+ * No ASCII tree, no 4a/4b labels.
  */
-function buildRoadmapMarkdown(planGraph = {}, {
+function buildFocusRoadmap(planGraph = {}, {
   cols = 80,
   taskRunLine = "",
-  maxRows = 10,
+  maxRows = 4,
 } = {}) {
   const dag = buildPlanDag(planGraph);
   if (dag.nodes.length === 0) {
     return { markdown: "", lines: [], dag };
   }
 
-  const titleMax = Math.max(12, Math.min(48, Math.floor(Number(cols) || 80) - 12));
-  const objective = truncate(String(planGraph.objective || "").trim(), titleMax);
-  const lines = [objective ? `**Plan** · ${objective}` : "**Plan**"];
+  const titleMax = titleMaxForCols(cols, 8);
+  const { done, total } = countDagProgress(dag);
+  const lines = [`**Plan** · ${done}/${total}`];
 
-  if (dag.linear) {
-    dag.waves.forEach((wave, waveIndex) => {
-      const node = wave[0];
-      lines.push(`${waveIndex + 1}. ${node.mark} ${truncate(node.title, titleMax)}`);
-    });
-  } else {
-    dag.waves.forEach((wave, waveIndex) => {
-      if (wave.length === 1) {
-        const node = wave[0];
-        lines.push(`${waveStepLabel(waveIndex, 0, 1)} ${node.mark} ${truncate(node.title, titleMax)}`);
-        return;
-      }
-      for (const line of formatParallelWaveLines(wave, waveIndex, Math.max(8, titleMax - 4))) {
-        lines.push(line);
-      }
-    });
+  const active = pickFocusActiveNodes(dag);
+  const activeIds = new Set(active.map((node) => node.id));
+  for (const node of active) {
+    lines.push(`${node.mark} ${truncate(node.title, titleMax)}`);
   }
 
-  const extra = String(taskRunLine || "").trim();
-  if (extra) lines.push(extra);
-
-  const limit = Number.isFinite(maxRows) && maxRows > 0 ? Math.floor(maxRows) : 10;
-  let clipped = lines.slice(0, Math.max(1, limit));
-  if (lines.length > clipped.length) {
-    clipped = clipped.slice(0, Math.max(1, limit - 1));
-    clipped.push(`… +${lines.length - clipped.length} more`);
+  const upcoming = pickUpcomingNodes(dag, activeIds, 2);
+  if (upcoming.length > 0) {
+    const titles = upcoming.map((node) => truncate(node.title, Math.max(8, Math.floor(titleMax / upcoming.length))));
+    lines.push(`接下来 · ${titles.join(" · ")}`);
   }
 
+  const extra = String(taskRunLine || "").trim();
+  if (extra) lines.push(truncate(extra, Math.max(24, titleMax + 8)));
+
+  const clipped = clipRoadmapLines(lines, maxRows);
   return {
     markdown: clipped.join("\n"),
     lines: clipped,
@@ -366,6 +382,89 @@ function buildRoadmapMarkdown(planGraph = {}, {
   };
 }
 
+/**
+ * Expanded (/plan focus): flat numbered list; parallel waves share a step number.
+ */
+function buildExpandedRoadmap(planGraph = {}, {
+  cols = 80,
+  taskRunLine = "",
+  maxRows = 16,
+} = {}) {
+  const dag = buildPlanDag(planGraph);
+  if (dag.nodes.length === 0) {
+    return { markdown: "", lines: [], dag };
+  }
+
+  const titleMax = titleMaxForCols(cols, 14);
+  const { done, total } = countDagProgress(dag);
+  const objective = truncate(String(planGraph.objective || "").trim(), Math.max(12, titleMax - 8));
+  const header = objective
+    ? `**Plan** · ${done}/${total} · ${objective}`
+    : `**Plan** · ${done}/${total}`;
+  const body = [];
+
+  dag.waves.forEach((wave, waveIndex) => {
+    const step = waveIndex + 1;
+    for (const node of wave) {
+      body.push(`${node.mark} ${step} ${truncate(node.title, titleMax)}`);
+    }
+  });
+
+  const extra = String(taskRunLine || "").trim();
+  if (extra) body.push(truncate(extra, Math.max(24, titleMax + 8)));
+
+  const budget = Math.max(1, (Number.isFinite(maxRows) ? Math.floor(maxRows) : 16) - 1);
+  let clippedBody = body;
+  if (body.length > budget) {
+    let windowStart = 0;
+    while (
+      windowStart < body.length
+      && (body[windowStart].startsWith("✓") || body[windowStart].startsWith("⊘"))
+    ) {
+      windowStart += 1;
+    }
+    // Keep one completed row before the live window for context.
+    windowStart = Math.max(0, windowStart - 1);
+    const window = body.slice(windowStart);
+    if (window.length <= budget) {
+      clippedBody = windowStart > 0
+        ? [`… +${windowStart} more`, ...window]
+        : window;
+    } else {
+      const kept = window.slice(0, Math.max(1, budget - 1));
+      const omittedAfter = body.length - (windowStart + kept.length);
+      clippedBody = windowStart > 0
+        ? [`… +${windowStart} more`, ...kept.slice(0, Math.max(1, budget - 2)), `… +${omittedAfter} more`]
+        : [...kept, `… +${omittedAfter} more`];
+      // If double ellipsis blew the budget, fall back to simple clip.
+      if (clippedBody.length > budget) {
+        clippedBody = clipRoadmapLines(body, budget);
+      }
+    }
+  }
+
+  const lines = [header, ...clippedBody];
+  return {
+    markdown: lines.join("\n"),
+    lines,
+    dag,
+  };
+}
+
+/**
+ * Build roadmap markdown from planGraph JSON.
+ * variant=focus (default auto band) or expanded (/plan focus).
+ */
+function buildRoadmapMarkdown(planGraph = {}, options = {}) {
+  const variant = String(options.variant || "focus").trim().toLowerCase() === "expanded"
+    ? "expanded"
+    : "focus";
+  if (variant === "expanded") {
+    return buildExpandedRoadmap(planGraph, options);
+  }
+  return buildFocusRoadmap(planGraph, options);
+}
+
 function buildDebugLines(executionState = null, planGraph = {}) {
   const lines = [];
   const pg = planGraph && typeof planGraph === "object" ? planGraph : {};
@@ -491,27 +590,27 @@ function buildPlanUiProjection(executionState = null, options = {}) {
       )];
       roadmapMarkdown = "";
     } else {
-      // auto + expanded: JSON → DAG → roadmap markdown
+      // auto → progress-focus; expanded → flat numbered list (no ASCII tree)
+      const variant = bandMode === "expanded" ? "expanded" : "focus";
       const maxRows = Number.isFinite(options.maxBandRows)
         ? options.maxBandRows
-        : (bandMode === "expanded" ? 16 : 10);
+        : (variant === "expanded" ? 16 : 4);
       const roadmap = buildRoadmapMarkdown(pg, {
         cols,
         taskRunLine: taskRunSuffix,
         maxRows,
+        variant,
       });
       planDag = roadmap.dag;
       roadmapMarkdown = roadmap.markdown;
       bandLines = roadmap.lines.slice();
-      if (bandMode === "expanded" && tree.length > 0) {
-        // Keep tree as fallback detail only when roadmap empty (shouldn't happen).
-        if (bandLines.length === 0) {
-          const title = pg.objective ? `Plan · ${pg.objective}` : "Plan";
-          bandLines = [truncate(title, Math.max(24, cols - 2))];
-          for (const row of tree) {
-            bandLines.push(truncate(formatTreeLine(row), Math.max(24, cols - 2)));
-          }
+      if (bandLines.length === 0 && tree.length > 0) {
+        const title = pg.objective ? `Plan · ${pg.objective}` : "Plan";
+        bandLines = [truncate(title, Math.max(24, cols - 2))];
+        for (const row of tree) {
+          bandLines.push(truncate(formatTreeLine(row), Math.max(24, cols - 2)));
         }
+        roadmapMarkdown = "";
       }
     }
   }
@@ -585,5 +684,7 @@ module.exports = {
   statusToMark,
   buildPlanDag,
   buildRoadmapMarkdown,
+  buildFocusRoadmap,
+  buildExpandedRoadmap,
   buildPlanUiProjection,
 };

package/src/code/contextWindow.js

@@ -0,0 +1,117 @@
+"use strict";
+
+/**
+ * Context-window helpers for the ucode TUI meter (used / limit in K).
+ *
+ * usedTokens comes from the latest model request's prompt occupancy.
+ * limitTokens is resolved from the model id (provider catalogs rarely
+ * expose a reliable context_window field).
+ */
+
+function toTokenCount(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return 0;
+  return Math.floor(parsed);
+}
+
+/**
+ * Prompt-side tokens currently occupying the context window.
+ * Anthropic splits input / cache_read / cache_creation; OpenAI folds
+ * cache hits into prompt_tokens (cached_tokens is a subset).
+ */
+function contextTokensFromUsage(usage = null) {
+  if (!usage || typeof usage !== "object") return 0;
+  const input = toTokenCount(usage.input);
+  const cacheRead = toTokenCount(usage.cacheRead);
+  const cacheCreation = toTokenCount(usage.cacheCreation);
+  if (cacheCreation > 0) return input + cacheRead + cacheCreation;
+  // Anthropic exclusive split: input can be smaller than cache_read alone.
+  if (cacheRead > 0 && input < cacheRead) return input + cacheRead + cacheCreation;
+  // OpenAI-compatible: prompt_tokens already includes cached tokens.
+  return input;
+}
+
+function resolveModelContextLimit(model = "", options = {}) {
+  const override = toTokenCount(options.limit || options.contextLimit);
+  if (override > 0) return override;
+
+  const id = String(model || "").trim().toLowerCase();
+  if (!id) return 200000;
+
+  if (/\b1m\b|1000000|million|1\.0m/.test(id)) return 1000000;
+  if (/256k/.test(id)) return 256000;
+  if (/128k/.test(id)) return 128000;
+  if (/64k/.test(id)) return 64000;
+  if (/32k/.test(id)) return 32000;
+
+  if (/claude|anthropic|opus|sonnet|haiku/.test(id)) return 200000;
+  if (/gemini|gemma/.test(id)) return 1000000;
+  if (/kimi|moonshot|k2\.|k2-|k3/.test(id)) return 256000;
+  if (/gpt-5|o3|o4|codex/.test(id)) return 200000;
+  if (/gpt-4\.1|gpt-4o|gpt-4-turbo|o1/.test(id)) return 128000;
+  if (/gpt-4|gpt-3\.5/.test(id)) return 128000;
+
+  return 200000;
+}
+
+function formatTokensK(tokens = 0) {
+  const n = Math.max(0, Math.floor(Number(tokens) || 0));
+  if (n < 1000) return String(n);
+  const k = n / 1000;
+  if (k >= 100) return `${Math.round(k)}K`;
+  const tenths = Math.round(k * 10) / 10;
+  if (Number.isInteger(tenths)) return `${tenths}K`;
+  return `${tenths.toFixed(1)}K`;
+}
+
+function formatContextMeter({ usedTokens = 0, limitTokens = 0 } = {}) {
+  const used = Math.max(0, Math.floor(Number(usedTokens) || 0));
+  const limit = Math.max(0, Math.floor(Number(limitTokens) || 0));
+  if (limit > 0) return `${formatTokensK(used)} / ${formatTokensK(limit)}`;
+  return formatTokensK(used);
+}
+
+function buildContextMeter({
+  usage = null,
+  usedTokens = null,
+  model = "",
+  limitTokens = null,
+} = {}) {
+  const used = usedTokens != null
+    ? toTokenCount(usedTokens)
+    : contextTokensFromUsage(usage);
+  const limit = resolveModelContextLimit(model, { limit: limitTokens });
+  return {
+    usedTokens: used,
+    limitTokens: limit,
+    model: String(model || "").trim(),
+    label: formatContextMeter({ usedTokens: used, limitTokens: limit }),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+function normalizeContextMeter(value = null, model = "") {
+  const source = value && typeof value === "object" ? value : {};
+  const used = toTokenCount(source.usedTokens);
+  const limit = resolveModelContextLimit(
+    String(source.model || model || "").trim(),
+    { limit: source.limitTokens },
+  );
+  return {
+    usedTokens: used,
+    limitTokens: limit,
+    model: String(source.model || model || "").trim(),
+    label: formatContextMeter({ usedTokens: used, limitTokens: limit }),
+    updatedAt: String(source.updatedAt || "").trim(),
+  };
+}
+
+module.exports = {
+  toTokenCount,
+  contextTokensFromUsage,
+  resolveModelContextLimit,
+  formatTokensK,
+  formatContextMeter,
+  buildContextMeter,
+  normalizeContextMeter,
+};