u-foo 2.5.15 → 3.0.1

package/src/code/taskDecomposer.js

@@ -4,8 +4,34 @@
  */
 
 const { runNativeAgentTask } = require("./nativeRunner");
-const { isContextV2Enabled } = require("./context/featureFlag");
 const { assembleModelContext, recordToolCallInSession } = require("./context/assembler");
+const fs = require("fs");
+const {
+  buildSkillManifest,
+  renderActiveSkillBlock,
+} = require("./skills");
+const { sanitizeSkillContent } = require("./skills/injection");
+
+function renderActiveSkillBodiesFromState(state = {}) {
+  const skills = Array.isArray(state.activeSkills) ? state.activeSkills : [];
+  const blocks = [];
+  for (const skill of skills) {
+    const skillPath = String(skill && skill.path || "").trim();
+    if (!skillPath) continue;
+    try {
+      const raw = fs.readFileSync(skillPath, "utf8");
+      const content = sanitizeSkillContent(raw);
+      const manifest = buildSkillManifest({
+        name: skill.name || "",
+        path: skillPath,
+      }, { bodyArtifactId: skill.bodyArtifactId || "" });
+      blocks.push(renderActiveSkillBlock(manifest, content));
+    } catch {
+      // ignore missing skill bodies
+    }
+  }
+  return blocks;
+}
 
 /**
  * Decompose a bug fix task into manageable steps
@@ -135,13 +161,11 @@ async function runDecomposedTask({
   messages = [],
   sessionId = "",
   state = null,
-  contextV2 = false,
   systemBlocks = null,
 }) {
   const steps = decomposeBugFixTask(task);
   const results = [];
   let aborted = false;
-  const useV2 = Boolean(contextV2 || isContextV2Enabled());
 
   // Check if already aborted
   if (signal && signal.aborted) {
@@ -174,12 +198,13 @@ async function runDecomposedTask({
       let stepMessages = messages;
       let stepSystemPrompt = systemPrompt;
       let stepSystemBlocks = systemBlocks;
-      if (useV2 && state) {
+      if (state) {
+        const skillBodies = renderActiveSkillBodiesFromState(state);
         const assembled = assembleModelContext(state, {
           workspaceRoot,
           model,
           provider,
-          turnDynamic: stepPrompt,
+          turnDynamic: [...skillBodies, stepPrompt].filter(Boolean).join("\n\n"),
         });
         stepMessages = assembled.messages;
         stepSystemPrompt = assembled.systemPrompt;
@@ -197,13 +222,12 @@ async function runDecomposedTask({
         timeoutMs: step.timeoutMs,
         onToolEvent,
         signal,
-        contextV2: useV2,
-        onArtifactPersisted: useV2 && state
+        onArtifactPersisted: state
           ? (persisted) => recordToolCallInSession(state, persisted, workspaceRoot)
           : null,
       });
 
-      if (useV2 && state && stepResult && Array.isArray(stepResult.messages)) {
+      if (state && stepResult && Array.isArray(stepResult.messages)) {
         const { syncMessagesToTranscript } = require("./context/assembler");
         syncMessagesToTranscript(state, stepResult.messages, workspaceRoot);
       }

package/src/code/taskRoute.js

@@ -0,0 +1,73 @@
+"use strict";
+
+/**
+ * Structural / explicit decomposition upgrade decisions (R7).
+ * Not a language-specific bug-keyword classifier.
+ */
+
+function shouldUpgradeToDecomposition(task = "", options = {}) {
+  const text = String(task || "").trim();
+  const reasons = [];
+
+  if (options.forceDirect === true || options.disableDecomposition === true) {
+    return {
+      upgrade: false,
+      reason: "forced_direct",
+      reasons: ["forced_direct"],
+    };
+  }
+  if (options.forceDecomposition === true || options.forceDecompose === true) {
+    return {
+      upgrade: true,
+      reason: "forced_decomposition",
+      reasons: ["forced_decomposition"],
+    };
+  }
+  if (!text) {
+    return { upgrade: false, reason: "empty", reasons: ["empty"] };
+  }
+
+  // Explicit user/model requests (EN + ZH).
+  if (/(?:\bdecompos(?:e|ition)\b|\bbreak\s+(?:this|it)\s+down\b|\bmulti[- ]?step\s+plan\b|拆解|分步|分解任务|制定计划)/i.test(text)) {
+    reasons.push("explicit_decompose_request");
+  }
+
+  // Multiple independently verifiable goals (numbered / bulleted / conjunctions).
+  const numbered = (text.match(/(?:^|\n)\s*(?:\d+[\).]|[-*•])\s+\S+/g) || []).length;
+  if (numbered >= 2) reasons.push("multiple_listed_goals");
+
+  const multiClause = /(?:^|[;；。\n])\s*(?:and\s+also|also|然后|并且|同时|另外|以及)\b/i.test(text)
+    || (text.split(/[;；]/).map((s) => s.trim()).filter((s) => s.length > 12).length >= 3);
+  if (multiClause) reasons.push("multi_clause_objectives");
+
+  // High-risk / multi-file structural cues (not "fix" alone).
+  if (/\b(?:across\s+(?:files?|modules?|packages?)|multiple\s+files?|refactor\s+the\s+\w+|迁移|跨文件|多文件)\b/i.test(text)) {
+    reasons.push("multi_file_or_refactor_scope");
+  }
+  if (/\b(?:checkpoint|rollback|migration|schema\s+change|生产环境|回滚)\b/i.test(text)) {
+    reasons.push("high_risk_change");
+  }
+
+  // Runtime budget / prior failures may request upgrade.
+  if (Number(options.failureCount || 0) >= 2) {
+    reasons.push("repeated_failures");
+  }
+  if (options.modelRequestedUpgrade === true) {
+    reasons.push("model_route_decision");
+  }
+  if (options.hasPlanGraph === true) {
+    // Already structured — keep direct loop unless other reasons fire.
+    // (graph exists is not itself a decompose trigger)
+  }
+
+  const upgrade = reasons.length > 0;
+  return {
+    upgrade,
+    reason: upgrade ? reasons[0] : "direct_default",
+    reasons,
+  };
+}
+
+module.exports = {
+  shouldUpgradeToDecomposition,
+};

package/src/code/tools/askUser.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const { runAskUserTool } = require("../context/userInteraction");
+
+function runAskUserToolDispatch(args = {}, options = {}) {
+  return runAskUserTool(args, options);
+}
+
+module.exports = {
+  runAskUserTool: runAskUserToolDispatch,
+};

package/src/code/tools/planGraph.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const {
+  runPlanGraphCommand,
+  normalizePlanGraphCommand,
+} = require("../context/planGraphService");
+
+function runPlanGraphTool(args = {}, options = {}) {
+  const command = normalizePlanGraphCommand(args) || args;
+  const result = runPlanGraphCommand(command, {
+    executionState: options.executionState,
+    runTool: options.runTool,
+    autoAdvance: options.autoAdvance !== false,
+    parallel: options.parallel !== false,
+    knownTools: options.knownTools,
+    maxNodeRuns: options.maxNodeRuns,
+  });
+
+  const payload = result.modelPayload || result;
+  return {
+    ok: payload.status === "accepted",
+    ...payload,
+    executionState: result.executionState,
+  };
+}
+
+module.exports = {
+  runPlanGraphTool,
+};

package/src/ui/format/index.js

@@ -129,7 +129,16 @@ function normalizeModelLabel(model = "") {
   return "default";
 }
 
-function buildUcodeBannerLines({ model = "", engine = "ufoo-core", nickname = "", agentId = "", workspaceRoot = "", sessionId = "", width = 0 } = {}) {
+function buildUcodeBannerLines({
+  model = "",
+  engine = "ufoo-core",
+  nickname = "",
+  agentId = "",
+  workspaceRoot = "",
+  sessionId = "",
+  width = 0,
+  planMode = false,
+} = {}) {
   const modelLabel = normalizeModelLabel(model);
   void width;
   void engine;
@@ -151,6 +160,9 @@ function buildUcodeBannerLines({ model = "", engine = "ufoo-core", nickname = ""
   const infoLines = [];
   infoLines.push(`${chalk.dim("Version:")} ${chalk.cyan.bold(UCODE_VERSION)}`);
   infoLines.push(`${chalk.dim("Model:")} ${chalk.yellow(modelLabel)}`);
+  if (planMode) {
+    infoLines.push(`${chalk.dim("Mode:")} ${chalk.magenta.bold("PLAN")}`);
+  }
   infoLines.push(`${chalk.dim("Dictionary:")} ${chalk.gray(shortPath)}`);
   const normalizedSessionId = String(sessionId || "").trim();
   if (normalizedSessionId) {
@@ -254,6 +266,16 @@ function renderLogLinesWithMarkdownAnsi(text = "", state = {}) {
   return renderMarkdownLinesAnsi(text, state);
 }
 
+function createMarkdownTableBuffer() {
+  const { createMarkdownTableBuffer: create } = require("./markdownRenderer");
+  return create();
+}
+
+function isTableRowLine(line = "") {
+  const { isTableRowLine: check } = require("./markdownRenderer");
+  return check(line);
+}
+
 function messageContentText(message = {}) {
   if (!message || typeof message !== "object") return "";
   const content = message.content;
@@ -1233,6 +1255,8 @@ module.exports = {
   planProjectsRail,
   renderLogLinesWithMarkdown,
   renderLogLinesWithMarkdownAnsi,
+  createMarkdownTableBuffer,
+  isTableRowLine,
   resolveAgentSelectionOnDown,
   resolveHistoryDownTransition,
   shouldClearAgentSelectionOnUp,

package/src/ui/format/markdownRenderer.js

@@ -3,7 +3,8 @@
  *
  * Produces either blessed tags (chat / legacy) or chalk ANSI (Ink ucode).
  * Terminals cannot change font size, so headings/emphasis use color + weight
- * instead of literal `#` / `**` markers.
+ * instead of literal `#` / `**` markers. GFM pipe tables are aligned into a
+ * compact spreadsheet-like grid.
  */
 
 const chalk = require("chalk");
@@ -15,6 +16,116 @@ function stripLeakedEscapeTags(text = "") {
   return withoutDanglingEscape.replace(/\{\s*\/?\s*e?s?c?a?p?e?[^{}\n]*$/gi, "");
 }
 
+/** Visible width for CJK-aware table padding (no ANSI). */
+function visibleWidth(text = "") {
+  let width = 0;
+  for (const char of String(text || "")) {
+    const code = char.codePointAt(0) || 0;
+    if (code < 32 || (code >= 0x7f && code < 0xa0)) continue;
+    if (
+      (code >= 0x1100 && code <= 0x115f)
+      || code === 0x2329
+      || code === 0x232a
+      || (code >= 0x2e80 && code <= 0xa4cf)
+      || (code >= 0xac00 && code <= 0xd7a3)
+      || (code >= 0xf900 && code <= 0xfaff)
+      || (code >= 0xfe10 && code <= 0xfe19)
+      || (code >= 0xfe30 && code <= 0xfe6f)
+      || (code >= 0xff00 && code <= 0xff60)
+      || (code >= 0xffe0 && code <= 0xffe6)
+    ) {
+      width += 2;
+      continue;
+    }
+    width += 1;
+  }
+  return width;
+}
+
+function isTableSeparatorLine(line = "") {
+  const raw = String(line || "").trim();
+  if (!raw.includes("-")) return false;
+  return /^\|?(\s*:?-+:?\s*\|)+\s*:?-+:?\s*\|?$/.test(raw);
+}
+
+function isTableRowLine(line = "") {
+  const raw = String(line || "").trim();
+  if (!raw.includes("|")) return false;
+  if (isTableSeparatorLine(raw)) return true;
+  // Prefer GFM pipe rows (`| a | b |`). Also allow compact `a | b | c`
+  // (at least two pipes). Lone prose like `A | B` is not a table row.
+  if (/^\|.*\|$/.test(raw)) return true;
+  const parts = raw.split("|");
+  return parts.length >= 3 && parts.some((p) => p.trim().length > 0);
+}
+
+/**
+ * Buffers consecutive GFM table rows so they can be rendered as one block
+ * (column widths need the full table). Call flush() before non-table output.
+ */
+function createMarkdownTableBuffer() {
+  const rows = [];
+  return {
+    get size() {
+      return rows.length;
+    },
+    push(line = "") {
+      const raw = String(line == null ? "" : line);
+      if (!isTableRowLine(raw)) return false;
+      rows.push(raw);
+      return true;
+    },
+    flush() {
+      if (rows.length === 0) return null;
+      const text = rows.join("\n");
+      rows.length = 0;
+      return text;
+    },
+  };
+}
+
+function parseTableCells(line = "") {
+  let raw = String(line || "").trim();
+  if (raw.startsWith("|")) raw = raw.slice(1);
+  if (raw.endsWith("|")) raw = raw.slice(0, -1);
+  return raw.split("|").map((cell) => cell.trim());
+}
+
+function parseSeparatorAlignments(line = "", columnCount = 0) {
+  const cells = parseTableCells(line);
+  const aligns = cells.map((cell) => {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    if (left && right) return "center";
+    if (right) return "right";
+    return "left";
+  });
+  while (aligns.length < columnCount) aligns.push("left");
+  return aligns.slice(0, Math.max(columnCount, aligns.length));
+}
+
+function alignCell(text = "", width = 0, align = "left") {
+  const value = String(text || "");
+  const current = visibleWidth(value);
+  if (current >= width) return value;
+  const pad = width - current;
+  if (align === "right") return `${" ".repeat(pad)}${value}`;
+  if (align === "center") {
+    const left = Math.floor(pad / 2);
+    const right = pad - left;
+    return `${" ".repeat(left)}${value}${" ".repeat(right)}`;
+  }
+  return `${value}${" ".repeat(pad)}`;
+}
+
+function plainCellWidth(cell = "") {
+  const plain = String(cell || "")
+    .replace(/\*\*|__/g, "")
+    .replace(/`/g, "")
+    .replace(/\*/g, "");
+  return visibleWidth(plain);
+}
+
 function createBlessedAdapters(escapeFn = (value) => String(value || "")) {
   const escape = (value) => escapeFn(value);
   return {
@@ -40,6 +151,11 @@ function createBlessedAdapters(escapeFn = (value) => String(value || "")) {
     fenceClose: () => "{gray-fg}└{/gray-fg}",
     fenceBody: (value) => `{gray-fg}│{/gray-fg} {white-fg}${escape(value)}{/white-fg}`,
     error: (value) => `{red-fg}${value}{/red-fg}`,
+    tablePipe: () => "{gray-fg}│{/gray-fg}",
+    tableSepCross: () => "{gray-fg}┼{/gray-fg}",
+    tableSepH: () => "{gray-fg}─{/gray-fg}",
+    tableHeaderCell: (value) => `{bold}{white-fg}${value}{/white-fg}{/bold}`,
+    tableCell: (value) => value,
   };
 }
 
@@ -76,6 +192,11 @@ function createAnsiAdapters() {
     fenceClose: () => paint.gray("└"),
     fenceBody: (value) => `${paint.gray("│")} ${paint.white(String(value || ""))}`,
     error: (value) => paint.red(String(value || "")),
+    tablePipe: () => paint.gray("│"),
+    tableSepCross: () => paint.gray("┼"),
+    tableSepH: () => paint.gray("─"),
+    tableHeaderCell: (value) => paint.bold.whiteBright(String(value || "")),
+    tableCell: (value) => String(value || ""),
   };
 }
 
@@ -161,6 +282,82 @@ function renderInlineMarkdown(input = "", adapters = createBlessedAdapters()) {
   return out;
 }
 
+function renderTableBlock(rawRows = [], adapters = createBlessedAdapters()) {
+  if (!Array.isArray(rawRows) || rawRows.length === 0) return [];
+
+  const rows = [];
+  let alignments = [];
+  let headerUsed = false;
+
+  for (let i = 0; i < rawRows.length; i += 1) {
+    const line = rawRows[i];
+    if (isTableSeparatorLine(line)) {
+      if (rows.length > 0 && !headerUsed) {
+        rows[rows.length - 1].isHeader = true;
+        headerUsed = true;
+      }
+      alignments = parseSeparatorAlignments(line, Math.max(alignments.length, parseTableCells(line).length));
+      continue;
+    }
+    rows.push({
+      cells: parseTableCells(line),
+      isHeader: false,
+    });
+  }
+
+  if (rows.length === 0) return [];
+
+  const columnCount = rows.reduce((max, row) => Math.max(max, row.cells.length), 0);
+  while (alignments.length < columnCount) alignments.push("left");
+
+  const widths = Array.from({ length: columnCount }, () => 1);
+  for (const row of rows) {
+    for (let c = 0; c < columnCount; c += 1) {
+      widths[c] = Math.max(widths[c], plainCellWidth(row.cells[c] || ""));
+    }
+  }
+
+  const pipe = adapters.tablePipe || (() => "│");
+  const sepH = adapters.tableSepH || (() => "─");
+  const sepCross = adapters.tableSepCross || (() => "┼");
+  const styleHeader = adapters.tableHeaderCell || ((v) => v);
+  const styleCell = adapters.tableCell || ((v) => v);
+
+  const out = [];
+  let wroteHeaderSep = false;
+
+  for (const row of rows) {
+    const renderedCells = [];
+    for (let c = 0; c < columnCount; c += 1) {
+      const rawCell = row.cells[c] || "";
+      const inline = renderInlineMarkdown(rawCell, adapters);
+      const plain = String(rawCell)
+        .replace(/\*\*|__/g, "")
+        .replace(/`/g, "")
+        .replace(/\*/g, "");
+      const alignedPlain = alignCell(plain, widths[c], alignments[c] || "left");
+      const padRight = Math.max(0, visibleWidth(alignedPlain) - visibleWidth(plain));
+      const styled = row.isHeader ? styleHeader(inline) : styleCell(inline);
+      renderedCells.push(`${styled}${" ".repeat(padRight)}`);
+    }
+    out.push(`${pipe()} ${renderedCells.join(` ${pipe()} `)} ${pipe()}`);
+
+    if (row.isHeader && !wroteHeaderSep) {
+      const segments = widths.map((w) => {
+        const unit = sepH();
+        // sepH may be a styled string longer than 1 codepoint; repeat by width.
+        return unit.repeat(Math.max(1, w));
+      });
+      out.push(
+        `${pipe()}${sepH()}${segments.join(`${sepH()}${sepCross()}${sepH()}`)}${sepH()}${pipe()}`,
+      );
+      wroteHeaderSep = true;
+    }
+  }
+
+  return out;
+}
+
 function renderMarkdownLinesWithAdapters(text = "", state = {}, adapters = createBlessedAdapters()) {
   const renderState = state && typeof state === "object" ? state : {};
   if (typeof renderState.inCodeBlock !== "boolean") {
@@ -170,7 +367,8 @@ function renderMarkdownLinesWithAdapters(text = "", state = {}, adapters = creat
   const lines = String(text || "").split(/\r?\n/);
   const out = [];
 
-  for (const line of lines) {
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
     const raw = stripLeakedEscapeTags(String(line || ""));
     const fenceMatch = raw.match(/^(\s*)(`{3,}|~{3,})(.*)$/);
     if (fenceMatch) {
@@ -190,6 +388,24 @@ function renderMarkdownLinesWithAdapters(text = "", state = {}, adapters = creat
       continue;
     }
 
+    // GFM table block — collect contiguous pipe rows for column alignment.
+    if (isTableRowLine(raw)) {
+      const block = [raw];
+      let look = index + 1;
+      while (look < lines.length) {
+        const nextRaw = stripLeakedEscapeTags(String(lines[look] || ""));
+        if (!isTableRowLine(nextRaw)) break;
+        block.push(nextRaw);
+        look += 1;
+      }
+      const hasSep = block.some((row) => isTableSeparatorLine(row));
+      if (hasSep || block.length >= 2) {
+        out.push(...renderTableBlock(block, adapters));
+        index = look - 1;
+        continue;
+      }
+    }
+
     if (/^\s*(-{3,}|\*{3,}|_{3,})\s*$/.test(raw)) {
       out.push(adapters.rule());
       continue;
@@ -261,4 +477,10 @@ module.exports = {
   renderMarkdownLinesWithAdapters,
   createBlessedAdapters,
   createAnsiAdapters,
+  isTableRowLine,
+  isTableSeparatorLine,
+  parseTableCells,
+  renderTableBlock,
+  createMarkdownTableBuffer,
+  visibleWidth,
 };