u-foo 1.8.5 → 1.8.8

package/src/chat/inputMath.js

@@ -1,6 +1,53 @@
+const TAB_WIDTH = 4;
+const TAB_REPLACEMENT = " ".repeat(TAB_WIDTH);
+
+function expandTabs(value) {
+  return String(value || "").replace(/\t/g, TAB_REPLACEMENT);
+}
+
+/**
+ * Convert a cursor offset in the original text to an offset in the
+ * tab-expanded text.
+ */
+function originalToExpanded(text, pos) {
+  let origIdx = 0;
+  let expIdx = 0;
+  const str = String(text || "");
+  while (origIdx < pos && origIdx < str.length) {
+    if (str[origIdx] === "\t") {
+      expIdx += TAB_WIDTH;
+    } else {
+      expIdx += str[origIdx].length > 1 ? str[origIdx].length : 1;
+    }
+    origIdx += 1;
+  }
+  return expIdx;
+}
+
+/**
+ * Convert a cursor offset in the tab-expanded text back to an offset
+ * in the original text.
+ */
+function expandedToOriginal(text, expPos) {
+  let origIdx = 0;
+  let expIdx = 0;
+  const str = String(text || "");
+  while (expIdx < expPos && origIdx < str.length) {
+    if (str[origIdx] === "\t") {
+      expIdx += TAB_WIDTH;
+    } else {
+      expIdx += 1;
+    }
+    origIdx += 1;
+  }
+  return origIdx;
+}
+
 function safeStrWidth(strWidth, value) {
   if (typeof strWidth === "function") return strWidth(value);
-  return Array.from(String(value || "")).length;
+  // Fallback: expand tabs to 4 spaces for width calculation
+  const expanded = expandTabs(value);
+  return Array.from(expanded).length;
 }
 
 function getInnerWidth({ input, screen, promptWidth = 2 }) {
@@ -27,64 +74,154 @@ function getWrapWidth(input, fallbackWidth) {
   return Math.max(1, fallbackWidth || 1);
 }
 
+/**
+ * Simulate blessed's wrapping for a single logical line (no newlines).
+ * Returns { rows, lastCol }.
+ *
+ * Blessed preprocesses double-width chars by inserting a \x03 marker after
+ * each one, then wraps at character count = width. This means a double-width
+ * char at col (width - 1) overflows by 1 cell — only the \x03 marker wraps
+ * to the next line. We replicate this behavior so cursor math matches what
+ * blessed actually renders.
+ */
+function wrapLine(line, width, strWidth) {
+  const chars = Array.from(String(line || ""));
+  let col = 0;
+  let rows = 1;
+  for (const ch of chars) {
+    const w = safeStrWidth(strWidth, ch);
+    if (w === 0) continue;
+    if (col >= width) {
+      rows += 1;
+      col = col - width;
+    }
+    col += w;
+  }
+  if (col > width) {
+    rows += 1;
+    col = col - width;
+  } else if (col === width) {
+    rows += 1;
+    col = 0;
+  }
+  return { rows, lastCol: col };
+}
+
 function countLines(text, width, strWidth) {
   if (width <= 0) return 1;
-  const lines = String(text || "").split("\n");
+  // Expand tabs to match blessed's preprocessing
+  const expanded = expandTabs(text);
+  const lines = expanded.split("\n");
   let total = 0;
   for (const line of lines) {
-    const lineWidth = safeStrWidth(strWidth, line);
-    total += Math.max(1, Math.ceil(lineWidth / width));
+    const { rows, lastCol } = wrapLine(line, width, strWidth);
+    total += (lastCol === 0 && rows > 1) ? rows - 1 : rows;
   }
   return total;
 }
 
+/**
+ * Convert a cursor offset (pos) in the original text to a visual { row, col }.
+ * Expands tabs first to match blessed's wrapping, then simulates wrapping.
+ */
 function getCursorRowCol(text, pos, width, strWidth) {
   if (width <= 0) return { row: 0, col: 0 };
-  const before = String(text || "").slice(0, Math.max(0, pos));
+  const original = String(text || "");
+  const expanded = expandTabs(original);
+  const expPos = originalToExpanded(original, Math.max(0, pos));
+  const before = expanded.slice(0, Math.max(0, expPos));
   const lines = before.split("\n");
   let row = 0;
-  for (let i = 0; i < lines.length - 1; i += 1) {
-    const lineWidth = safeStrWidth(strWidth, lines[i]);
-    row += Math.max(1, Math.ceil(lineWidth / width));
-  }
-  const lastLine = lines[lines.length - 1] || "";
-  const lastWidth = safeStrWidth(strWidth, lastLine);
-  row += Math.floor(lastWidth / width);
-  const col = lastWidth % width;
-  return { row, col };
-}
 
-function getLinePosForCol(line, targetCol, strWidth) {
-  if (targetCol <= 0) return 0;
-  let col = 0;
-  let offset = 0;
-  for (const ch of Array.from(String(line || ""))) {
-    const w = safeStrWidth(strWidth, ch);
-    if (col + w > targetCol) return offset;
-    col += w;
-    offset += ch.length;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] || "";
+    if (i < lines.length - 1) {
+      const { rows, lastCol } = wrapLine(line, width, strWidth);
+      row += (lastCol === 0 && rows > 1) ? rows - 1 : rows;
+    } else {
+      const chars = Array.from(line);
+      let col = 0;
+      for (const ch of chars) {
+        const w = safeStrWidth(strWidth, ch);
+        if (w === 0) continue;
+        if (col >= width) {
+          row += 1;
+          col = col - width;
+        }
+        col += w;
+      }
+      if (col > width) {
+        row += 1;
+        col = col - width;
+      } else if (col === width) {
+        row += 1;
+        col = 0;
+      }
+      return { row, col };
+    }
   }
-  return offset;
+  return { row, col: 0 };
 }
 
+/**
+ * Convert a visual { targetRow, targetCol } back to a cursor offset in
+ * the original text. Expands tabs first to match blessed's wrapping.
+ */
 function getCursorPosForRowCol(text, targetRow, targetCol, width, strWidth) {
   if (width <= 0) return 0;
-  const source = String(text || "");
-  const lines = source.split("\n");
+  const original = String(text || "");
+  const expanded = expandTabs(original);
+  const lines = expanded.split("\n");
   let row = 0;
-  let pos = 0;
-  for (const line of lines) {
-    const lineWidth = safeStrWidth(strWidth, line);
-    const wrappedRows = Math.max(1, Math.ceil(lineWidth / width));
-    if (targetRow < row + wrappedRows) {
-      const rowInLine = targetRow - row;
-      const visualCol = rowInLine * width + Math.max(0, targetCol);
-      return pos + getLinePosForCol(line, visualCol, strWidth);
+  let expPos = 0;
+
+  for (let li = 0; li < lines.length; li += 1) {
+    const line = lines[li];
+    const chars = Array.from(line);
+    let col = 0;
+    let lineOffset = 0;
+
+    for (const ch of chars) {
+      const w = safeStrWidth(strWidth, ch);
+      if (w === 0) {
+        lineOffset += ch.length;
+        continue;
+      }
+      if (col >= width) {
+        row += 1;
+        col = col - width;
+      }
+      if (row === targetRow && col + w > targetCol) {
+        return expandedToOriginal(original, expPos + lineOffset);
+      }
+      col += w;
+      lineOffset += ch.length;
+      if (col > width) {
+        if (row === targetRow) {
+          return expandedToOriginal(original, expPos + lineOffset);
+        }
+        row += 1;
+        col = col - width;
+      } else if (col === width) {
+        if (row === targetRow) {
+          return expandedToOriginal(original, expPos + lineOffset);
+        }
+        row += 1;
+        col = 0;
+      }
     }
-    pos += line.length + 1;
-    row += wrappedRows;
+
+    if (row === targetRow) {
+      return expandedToOriginal(original, expPos + lineOffset);
+    }
+    if (row > targetRow) {
+      return expandedToOriginal(original, expPos + lineOffset);
+    }
+
+    expPos += line.length + 1;
+    row += 1;
   }
-  return source.length;
+  return original.length;
 }
 
 function normalizePaste(text) {

package/src/chat/inputSubmitHandler.js

@@ -1,4 +1,6 @@
 const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
+const { decodeEscapedNewlines } = require("./text");
+const { shouldEchoCommandInChat } = require("./commands");
 
 function createInputSubmitHandler(options = {}) {
   const {
@@ -69,7 +71,7 @@ function createInputSubmitHandler(options = {}) {
   }
 
   async function handleSubmit(value) {
-    const text = String(value || "").trim();
+    const text = decodeEscapedNewlines(value).trim();
 
     if (!text) {
       if (state.targetAgent) {
@@ -120,16 +122,17 @@ function createInputSubmitHandler(options = {}) {
         return;
       }
       const resolvedTarget = resolveAgentId(atTarget.target) || atTarget.target;
+      const message = atTarget.message.trim();
       logMessage(
         "user",
-        `{cyan-fg}→{/cyan-fg} {magenta-fg}@${escapeBlessed(atTarget.target)}{/magenta-fg} ${escapeBlessed(atTarget.message)}`
+        `{cyan-fg}→{/cyan-fg} {magenta-fg}@${escapeBlessed(atTarget.target)}{/magenta-fg} ${escapeBlessed(message)}`
       );
       renderScreen();  // Immediately render the user message
       markPendingDelivery(resolvedTarget);
       send({
         type: IPC_REQUEST_TYPES.BUS_SEND,
         target: resolvedTarget,
-        message: atTarget.message,
+        message,
         injection_mode: "immediate",
         source: "chat-direct",
       });
@@ -138,8 +141,10 @@ function createInputSubmitHandler(options = {}) {
     }
 
     if (text.startsWith("/")) {
-      logMessage("user", `{white-fg}→{/white-fg} ${escapeBlessed(text)}`);
-      renderScreen();  // Render slash command immediately
+      if (shouldEchoCommandInChat(text)) {
+        logMessage("user", `{white-fg}→{/white-fg} ${escapeBlessed(text)}`);
+        renderScreen();  // Render slash command immediately
+      }
       try {
         await executeCommand(text);
       } catch (err) {

package/src/chat/settingsController.js

@@ -9,6 +9,7 @@ function createSettingsController(options = {}) {
     fsModule,
     getUfooPaths = () => ({ agentDir: "" }),
     logMessage = () => {},
+    resolveStatusLine = null,
     renderDashboard = () => {},
     renderScreen = () => {},
     restartDaemon = () => {},
@@ -59,7 +60,8 @@ function createSettingsController(options = {}) {
     const nextIndex = modeOptions.findIndex((opt) => opt === next);
     setSelectedModeIndex(nextIndex >= 0 ? nextIndex : 0);
     saveConfig(projectRoot, { launchMode: next });
-    logMessage("status", `{white-fg}⚙{/white-fg} Launch mode: ${next}`);
+    const statusMsg = resolveStatusLine || ((text) => logMessage("status", text));
+    statusMsg(`{gray-fg}⚙{/gray-fg} Launch mode: ${next}`);
     renderDashboard();
     renderScreen();
     void restartDaemon();

package/src/chat/text.js

@@ -17,6 +17,11 @@ function escapeBlessed(text) {
   return `{escape}${safe}{/escape}`;
 }
 
+function decodeEscapedNewlines(text) {
+  if (text == null) return "";
+  return String(text).replace(/\\n/g, "\n");
+}
+
 function stripBlessedTags(text) {
   if (text == null) return "";
   return String(text).replace(/\{[^}]+\}/g, "");
@@ -63,6 +68,7 @@ function truncateText(text, maxWidth) {
 module.exports = {
   neutralizeBlessedCommaTags,
   escapeBlessed,
+  decodeEscapedNewlines,
   stripBlessedTags,
   stripAnsi,
   truncateAnsi,

package/src/code/agent.js

@@ -24,6 +24,7 @@ const {
   saveSessionSnapshot,
   loadSessionSnapshot,
 } = require("./sessionStore");
+const { buildPromptContext } = require("./prompts");
 
 function printPrompt() {
   process.stdout.write("> ");
@@ -553,14 +554,28 @@ function formatNlResult(result, asJson = false) {
 function buildNlContext({
   appendSystemPrompt = "",
   systemPrompt = "",
+  workspaceRoot = "",
+  model = "",
+  provider = "",
 } = {}) {
-  const inline = readTextOrFile(appendSystemPrompt) || readTextOrFile(systemPrompt);
-  if (inline) return clampContext(inline);
+  // Legacy override: if caller passes a raw systemPrompt string/file, honor it
+  const override = readTextOrFile(systemPrompt);
+  if (override) return clampContext(override);
 
-  const envFallback = readTextOrFile(process.env.UFOO_UCODE_APPEND_SYSTEM_PROMPT)
+  // Resolve append from args or env
+  const append = readTextOrFile(appendSystemPrompt)
+    || readTextOrFile(process.env.UFOO_UCODE_APPEND_SYSTEM_PROMPT)
     || readTextOrFile(process.env.UFOO_UCODE_BOOTSTRAP_FILE)
-    || readTextOrFile(process.env.UFOO_UCODE_PROMPT_FILE);
-  return clampContext(envFallback);
+    || readTextOrFile(process.env.UFOO_UCODE_PROMPT_FILE)
+    || "";
+
+  // New modular prompt assembly
+  return clampContext(buildPromptContext({
+    workspaceRoot: workspaceRoot || process.cwd(),
+    model,
+    provider,
+    appendSystemPrompt: append,
+  }));
 }
 
 function buildSessionSnapshotFromState(state = {}) {
@@ -1327,7 +1342,13 @@ async function runUcodeCoreAgent({
     provider: resolvedUcode.provider,
     model: resolvedUcode.model,
     engine: "ufoo-core",
-    context: buildNlContext({ appendSystemPrompt, systemPrompt }),
+    context: buildNlContext({
+      appendSystemPrompt,
+      systemPrompt,
+      workspaceRoot: resolvedWorkspaceRoot,
+      model: resolvedUcode.model,
+      provider: resolvedUcode.provider,
+    }),
     nlMessages: [],
     sessionId: resolveSessionId(String(sessionId || "").trim()),
     timeoutMs,

package/src/code/nativeRunner.js

@@ -1,6 +1,10 @@
 const { randomUUID } = require("crypto");
 const { loadConfig } = require("../config");
 const { runToolCall } = require("./dispatch");
+const { getReadToolDescription } = require("./prompts/toolDescriptions/read");
+const { getWriteToolDescription } = require("./prompts/toolDescriptions/write");
+const { getEditToolDescription } = require("./prompts/toolDescriptions/edit");
+const { getBashToolDescription } = require("./prompts/toolDescriptions/bash");
 
 const CORE_TOOL_NAMES = new Set(["read", "write", "edit", "bash"]);
 const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
@@ -244,7 +248,7 @@ function buildCoreToolSpecs() {
       type: "function",
       function: {
         name: "read",
-        description: "Read a text file from workspace.",
+        description: getReadToolDescription(),
         parameters: {
           type: "object",
           properties: {
@@ -261,7 +265,7 @@ function buildCoreToolSpecs() {
       type: "function",
       function: {
         name: "write",
-        description: "Write content to a file in workspace.",
+        description: getWriteToolDescription(),
         parameters: {
           type: "object",
           properties: {
@@ -277,7 +281,7 @@ function buildCoreToolSpecs() {
       type: "function",
       function: {
         name: "edit",
-        description: "Replace text in a file in workspace.",
+        description: getEditToolDescription(),
         parameters: {
           type: "object",
           properties: {
@@ -294,7 +298,7 @@ function buildCoreToolSpecs() {
       type: "function",
       function: {
         name: "bash",
-        description: "Run one shell command in workspace.",
+        description: getBashToolDescription(),
         parameters: {
           type: "object",
           properties: {

package/src/code/prompts/actions.js

@@ -0,0 +1,21 @@
+"use strict";
+
+function getActionsSection() {
+  return `# Executing actions with care
+
+Carefully consider the reversibility and blast radius of actions. File reads and edits are local and reversible. But bash commands can be destructive and hard to undo — think before running them.
+
+Actions that warrant extra caution:
+- Destructive operations: deleting files/branches, dropping database tables, rm -rf, overwriting uncommitted changes.
+- Hard-to-reverse operations: force-pushing, git reset --hard, amending published commits, removing packages.
+- Actions visible to others: pushing code, creating/closing PRs or issues, sending messages to external services.
+
+For git operations:
+- Prefer creating new commits over amending existing ones.
+- Never skip hooks (--no-verify) unless the user explicitly asks.
+- Never force-push to main/master without explicit user confirmation.
+
+When you encounter an obstacle, do not use destructive actions as a shortcut. Investigate before deleting or overwriting — unexpected files or branches may represent the user's in-progress work. When in doubt, ask before acting.`;
+}
+
+module.exports = { getActionsSection };

package/src/code/prompts/efficiency.js

@@ -0,0 +1,18 @@
+"use strict";
+
+function getOutputEfficiencySection() {
+  return `# Output efficiency
+
+Go straight to the point. Try the simplest approach first without going in circles.
+
+Keep your text output brief and direct. Lead with the answer or action, not the reasoning. Skip filler words, preamble, and unnecessary transitions. Do not restate what the user said — just do it.
+
+Focus text output on:
+- Decisions that need the user's input.
+- High-level status updates at natural milestones.
+- Errors or blockers that change the plan.
+
+If you can say it in one sentence, don't use three. Use deterministic, machine-consumable action patterns when applicable. This does not apply to code or tool calls.`;
+}
+
+module.exports = { getOutputEfficiencySection };

package/src/code/prompts/environment.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const { execSync } = require("child_process");
+const os = require("os");
+
+function getIsGit(workspaceRoot) {
+  try {
+    const result = execSync("git rev-parse --is-inside-work-tree", {
+      cwd: workspaceRoot || process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3000,
+    });
+    return String(result).trim() === "true";
+  } catch {
+    return false;
+  }
+}
+
+function getShellName() {
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("bash")) return "bash";
+  if (shell.includes("fish")) return "fish";
+  return shell || "unknown";
+}
+
+function getEnvironmentSection({ workspaceRoot = "", model = "", provider = "" } = {}) {
+  const cwd = workspaceRoot || process.cwd();
+  const isGit = getIsGit(cwd);
+  const platform = process.platform;
+  const shell = getShellName();
+  const osInfo = `${os.type()} ${os.release()}`;
+  const date = new Date().toISOString().slice(0, 10);
+
+  const lines = [
+    `Working directory: ${cwd}`,
+    `Is git repository: ${isGit ? "yes" : "no"}`,
+    `Platform: ${platform}`,
+    `Shell: ${shell}`,
+    `OS: ${osInfo}`,
+    `Date: ${date}`,
+  ];
+
+  if (provider) lines.push(`Provider: ${provider}`);
+  if (model) lines.push(`Model: ${model}`);
+
+  return `# Environment\n${lines.map((l) => ` - ${l}`).join("\n")}`;
+}
+
+module.exports = { getEnvironmentSection, getIsGit };

package/src/code/prompts/identity.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const SAFETY_INSTRUCTION = `Assist with authorized security testing, defensive security, and educational contexts. Refuse requests for destructive techniques, malicious code generation, or attacks targeting real systems without explicit authorization.`;
+
+function getIdentitySection() {
+  return `You are \`ucode\`, the ufoo coding agent core — a software engineering assistant that helps users with code tasks using the tools available to you.
+
+Objectives:
+- Deliver coding capability on par with leading coding agents.
+- Integrate natively with the ufoo multi-agent ecosystem.
+
+${SAFETY_INSTRUCTION}
+
+IMPORTANT: Never generate or guess URLs unless you are confident they help the user with programming. You may use URLs provided by the user in their messages or local files.`;
+}
+
+module.exports = {
+  SAFETY_INSTRUCTION,
+  getIdentitySection,
+};

package/src/code/prompts/index.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const { getIdentitySection } = require("./identity");
+const { getSystemSection } = require("./system");
+const { getDoingTasksSection } = require("./tasks");
+const { getActionsSection } = require("./actions");
+const { getSafetySection } = require("./safety");
+const { getOutputEfficiencySection } = require("./efficiency");
+const { getUfooIntegrationSection } = require("./ufoo");
+const { getEnvironmentSection } = require("./environment");
+const {
+  systemPromptSection,
+  resolveSections,
+  clearSectionCache,
+} = require("./sections");
+
+/**
+ * Boundary marker separating static (cacheable) content from dynamic content.
+ * Everything BEFORE this marker can be cached across turns.
+ * Everything AFTER contains session-specific content.
+ */
+const SYSTEM_PROMPT_DYNAMIC_BOUNDARY = "__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__";
+
+/**
+ * Assemble the full system prompt as a string array.
+ *
+ * Priority system (3 levels):
+ *   1. overrideSystemPrompt — completely replaces everything
+ *   2. Default — modular sections assembled below
+ *   3. appendSystemPrompt — always appended at the end
+ *
+ * @param {object} options
+ * @param {string} [options.workspaceRoot]
+ * @param {string} [options.model]
+ * @param {string} [options.provider]
+ * @param {string} [options.appendSystemPrompt]
+ * @param {string} [options.overrideSystemPrompt]
+ * @returns {string[]}
+ */
+function getSystemPrompt({
+  workspaceRoot = "",
+  model = "",
+  provider = "",
+  appendSystemPrompt = "",
+  overrideSystemPrompt = "",
+} = {}) {
+  // Priority 1: override replaces everything
+  if (overrideSystemPrompt) {
+    return [overrideSystemPrompt];
+  }
+
+  // --- Static sections (cacheable, computed once per session) ---
+  const staticSections = [
+    getIdentitySection(),
+    getSystemSection(),
+    getDoingTasksSection(),
+    getActionsSection(),
+    getSafetySection(),
+    getOutputEfficiencySection(),
+  ];
+
+  // --- Dynamic boundary ---
+  const boundary = SYSTEM_PROMPT_DYNAMIC_BOUNDARY;
+
+  // --- Dynamic sections (may change per session/turn) ---
+  const dynamicSectionDefs = [
+    systemPromptSection("ufoo", () => getUfooIntegrationSection()),
+    systemPromptSection("environment", () =>
+      getEnvironmentSection({ workspaceRoot, model, provider }),
+    ),
+  ];
+  const dynamicSections = resolveSections(dynamicSectionDefs);
+
+  // Assemble
+  const result = [
+    ...staticSections,
+    boundary,
+    ...dynamicSections,
+    appendSystemPrompt || null,
+  ].filter((s) => s != null && s !== "");
+
+  return result;
+}
+
+/**
+ * Build a single prompt context string from the modular sections.
+ * This is the main entry point for backward compatibility with agent.js.
+ *
+ * @param {object} options — same as getSystemPrompt
+ * @returns {string}
+ */
+function buildPromptContext(options = {}) {
+  return getSystemPrompt(options)
+    .filter((s) => s !== SYSTEM_PROMPT_DYNAMIC_BOUNDARY)
+    .join("\n\n");
+}
+
+module.exports = {
+  getSystemPrompt,
+  buildPromptContext,
+  clearSectionCache,
+  SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
+};

package/src/code/prompts/safety.js

@@ -0,0 +1,11 @@
+"use strict";
+
+function getSafetySection() {
+  return `# Safety
+ - Never output secrets, API keys, passwords, or credentials in your responses. If you encounter them in files, mention their presence without revealing the values.
+ - Do not commit files that likely contain secrets (.env, credentials.json, etc). Warn the user if they specifically request it.
+ - Refuse requests to generate malicious code, exploits targeting real systems, or code designed to cause harm.
+ - Be aware of workspace path boundaries — all file operations are scoped to the workspace root.`;
+}
+
+module.exports = { getSafetySection };