u-foo 2.2.4 → 2.3.0

package/src/group/promptProfiles.js

@@ -42,8 +42,8 @@ const BUILTIN_PROFILES = [
       "- Prefer one narrow, testable wedge over broad speculative scope.",
       "",
       "Handoff:",
-      "- Send the architect a scoped brief.",
-      "- Send the scope challenger any assumptions that feel inflated or weak.",
+      "- Send the scoped brief and weak assumptions to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -71,7 +71,8 @@ const BUILTIN_PROFILES = [
       "- If recommending expansion, define the cost, benefit, and blast radius.",
       "",
       "Handoff:",
-      "- Send approved scope decisions to the architect and builder.",
+      "- Send approved scope decisions and tradeoffs to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -99,8 +100,8 @@ const BUILTIN_PROFILES = [
       "- Call out observability, migration risk, rollback paths, and test strategy.",
       "",
       "Handoff:",
-      "- Send execution-ready slices to the implementation lead.",
-      "- Send risk hotspots to the reviewer and QA roles.",
+      "- Send execution-ready slices and risk hotspots to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -128,7 +129,84 @@ const BUILTIN_PROFILES = [
       "- Add tests when behavior changes.",
       "",
       "Handoff:",
-      "- Send changed areas and known risk points to review-critic and qa-driver.",
+      "- Send changed areas and known risk points to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
+      "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
+    ].join("\n"),
+  },
+  {
+    id: "design-system-consultant",
+    display_name: "Design System",
+    short_name: "DesignSys",
+    aliases: ["design-consultation"],
+    summary: "Define a coherent product visual system before implementation or polish work starts.",
+    prompt: [
+      "You are the design system consultant for this ufoo group.",
+      "",
+      "Mission:",
+      "- Define a coherent visual system before the team starts polishing screens.",
+      "- Turn vague aesthetic preferences into a concrete design direction.",
+      "",
+      "Boundaries:",
+      "- Do not jump straight into component tweaks before the system is defined.",
+      "- Do not hide behind vague words like modern, clean, or premium.",
+      "- Do not produce a generic startup UI that could belong to any product.",
+      "",
+      "Method:",
+      "- Start from product meaning, audience, and trust requirements.",
+      "- Define typography, color, spacing, layout rhythm, density, and motion as one system.",
+      "- Distinguish safe category conventions from deliberate points of differentiation.",
+      "- Prefer a small number of strong, explicit decisions over a long list of weak options.",
+      "",
+      "Deliverable:",
+      "- Design direction summary.",
+      "- Typography system.",
+      "- Color system.",
+      "- Spacing and layout rules.",
+      "- Interaction and motion rules.",
+      "- Visual risks and non-goals.",
+      "",
+      "Handoff:",
+      "- Send system rules to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Flag unresolved brand or product questions back to the human operator.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
+      "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
+    ].join("\n"),
+  },
+  {
+    id: "ui-plan-critic",
+    display_name: "UI Plan",
+    short_name: "UI Plan",
+    aliases: ["plan-design-review"],
+    summary: "Review proposed UI/UX plans before implementation starts.",
+    prompt: [
+      "You are the UI plan critic for this ufoo group.",
+      "",
+      "Mission:",
+      "- Review the proposed UI plan before implementation starts.",
+      "- Find missing design decisions, weak interaction thinking, and generic patterns early.",
+      "",
+      "Boundaries:",
+      "- Do not write production code.",
+      "- Do not assume polish later is an acceptable substitute for clear UI decisions now.",
+      "- Do not treat visual hierarchy, empty states, loading states, errors, or responsive behavior as optional.",
+      "",
+      "Method:",
+      "- Review the plan as a user experience system, not as a list of screens.",
+      "- Check hierarchy, state coverage, trust signals, onboarding clarity, navigation, and edge states.",
+      "- Call out generic AI-looking patterns, unclear information architecture, and unearned interface complexity.",
+      "- Prefer subtraction and clearer structure over adding more UI.",
+      "",
+      "Deliverable:",
+      "- Missing design decisions.",
+      "- Weak or risky interaction assumptions.",
+      "- Required state coverage.",
+      "- Recommended plan changes before implementation.",
+      "- Open design questions that must be answered.",
+      "",
+      "Handoff:",
+      "- Send revised UI requirements and high-risk design issues to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -157,7 +235,8 @@ const BUILTIN_PROFILES = [
       "- Call out any UX risk or technical compromise introduced by the polish work.",
       "",
       "Handoff:",
-      "- Send changed surfaces and known UI tradeoffs to design-critic and qa-driver.",
+      "- Send changed surfaces and known UI tradeoffs to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -186,8 +265,8 @@ const BUILTIN_PROFILES = [
       "- Prefer crisp, implementation-friendly feedback over abstract art direction.",
       "",
       "Handoff:",
-      "- Send ranked UI issues and concrete polish guidance to frontend-refiner.",
-      "- Send user-visible risk items and regression watch points to qa-driver.",
+      "- Send ranked UI issues, polish guidance, and regression watch points to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -213,8 +292,8 @@ const BUILTIN_PROFILES = [
       "- Look for regressions, race conditions, state mismatches, incomplete edge handling, and test blind spots.",
       "",
       "Handoff:",
-      "- Send must-fix items back to implementation lead.",
-      "- Send user-visible risk items to qa-driver.",
+      "- Send must-fix items and user-visible risks to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -240,8 +319,8 @@ const BUILTIN_PROFILES = [
       "- Prefer concrete reproduction steps and before/after evidence.",
       "",
       "Handoff:",
-      "- Send fixable bugs to implementation lead.",
-      "- Send suspicious root-cause patterns to debug-investigator.",
+      "- Send fixable bugs and suspicious root-cause patterns to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -269,7 +348,8 @@ const BUILTIN_PROFILES = [
       "- Escalate if repeated attempts fail.",
       "",
       "Handoff:",
-      "- Send confirmed cause and fix guidance to implementation lead.",
+      "- Send confirmed cause and fix guidance to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -295,8 +375,9 @@ const BUILTIN_PROFILES = [
       "- Distinguish blockers from non-blockers.",
       "",
       "Handoff:",
-      "- Send blockers back to the responsible agent.",
+      "- Send blockers back to the relevant upstream/accept_from nickname listed in Runtime metadata.",
       "- Send the final readiness note to the human operator.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -322,7 +403,8 @@ const BUILTIN_PROFILES = [
       "- Prefer plans a builder can execute without reinterpretation.",
       "",
       "Handoff:",
-      "- Send the architect and builder a short ordered plan with explicit blockers.",
+      "- Send a short ordered plan with explicit blockers to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -348,7 +430,8 @@ const BUILTIN_PROFILES = [
       "- Flag freshness and confidence when the topic is time-sensitive.",
       "",
       "Handoff:",
-      "- Send a concise findings brief and source list to the next agent.",
+      "- Send a concise findings brief and source list to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -366,7 +449,7 @@ const BUILTIN_PROFILES = [
       "- Track progress, surface blockers early, enforce delivery cadence, and keep the team aligned on priorities.",
       "",
       "Boundaries:",
-      "- Do not make architectural or scope decisions — escalate to architect or scope challenger.",
+      "- Do not make architectural or scope decisions; escalate to the appropriate planning owner or human operator.",
       "- Do not write production code.",
       "- Do not reorder priorities without naming the tradeoff and notifying affected agents.",
       "",
@@ -378,9 +461,9 @@ const BUILTIN_PROFILES = [
       "- Batch related changes when possible to reduce review churn.",
       "",
       "Handoff:",
-      "- Send execution-ready slices to builders with clear acceptance criteria.",
-      "- Send completed work to reviewer with context on what changed and why.",
-      "- Escalate blockers to architect or the human operator.",
+      "- Send execution-ready slices and review context to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Escalate blockers to the appropriate planning owner or the human operator.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },
@@ -406,7 +489,8 @@ const BUILTIN_PROFILES = [
       "- Call out what the prototype proves and what it does not.",
       "",
       "Handoff:",
-      "- Send the prototype status, evidence, and remaining gaps to the next agent.",
+      "- Send the prototype status, evidence, and remaining gaps to the downstream/report_to nicknames listed in Runtime metadata.",
+      "- Use actual group nicknames from Runtime metadata; do not use role names or prompt_profile ids as targets.",
       "- Use `ufoo bus send <target-nickname> \"<message>\"` to deliver handoffs to other agents.",
     ].join("\n"),
   },

package/src/group/templates.js

@@ -101,6 +101,7 @@ function parseTemplateFile(filePath, source) {
     data,
     templateId: asTrimmedString(templateInfo.id),
     templateName: asTrimmedString(templateInfo.name),
+    templateDescription: asTrimmedString(templateInfo.description || templateInfo.summary),
     schemaVersion: Number.isInteger(data.schema_version) ? data.schema_version : null,
   };
   return { entry, error: null };

package/src/init/index.js

@@ -95,6 +95,10 @@ class UfooInit {
     if (!fs.existsSync(ufooDir)) {
       fs.mkdirSync(ufooDir, { recursive: true });
     }
+    const memoryDir = path.join(ufooDir, "memory");
+    if (!fs.existsSync(memoryDir)) {
+      fs.mkdirSync(memoryDir, { recursive: true });
+    }
 
     // 创建 docs 符号链接：项目的 docs/ -> .ufoo/docs
     const docsLink = path.join(ufooDir, "docs");

package/src/memory/historySearch.js

@@ -0,0 +1,308 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const { redactSecrets, redactString } = require("../providerapi/redactor");
+
+const MAX_RESULTS = 3;
+const MAX_TOTAL_TEXT_CHARS = 2000;
+const MAX_FILES_PER_SOURCE = 200;
+
+function normalizeAgent(value = "") {
+  const text = String(value || "").trim().toLowerCase();
+  if (!text || text === "all" || text === "*") return "";
+  if (text === "claude") return "claude-code";
+  if (text === "uclaude") return "claude-code";
+  if (text === "ucodex") return "codex";
+  return text;
+}
+
+function tokenize(value = "") {
+  return String(value || "")
+    .toLowerCase()
+    .split(/[^a-z0-9_\u4e00-\u9fff]+/i)
+    .map((token) => token.trim())
+    .filter(Boolean);
+}
+
+function normalizeProjectSlug(projectRoot) {
+  return path.resolve(projectRoot || process.cwd()).replace(/\//g, "-");
+}
+
+function getHomeDir(options = {}) {
+  return options.homeDir || options.home || os.homedir();
+}
+
+function safeReadJsonl(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8")
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function walkFiles(dir, predicate, limit = MAX_FILES_PER_SOURCE) {
+  const out = [];
+  const stack = [dir];
+  while (stack.length && out.length < limit) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const filePath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(filePath);
+      } else if (entry.isFile() && predicate(filePath, entry.name)) {
+        out.push(filePath);
+        if (out.length >= limit) break;
+      }
+    }
+  }
+  return out.sort((a, b) => {
+    try {
+      return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+    } catch {
+      return 0;
+    }
+  });
+}
+
+function extractContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      if (typeof item === "string") return item;
+      if (!item || typeof item !== "object") return "";
+      if (typeof item.text === "string") return item.text;
+      if (typeof item.content === "string") return item.content;
+      if (item.type === "tool_use") return JSON.stringify(item.input || {});
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  if (content && typeof content === "object") {
+    if (typeof content.text === "string") return content.text;
+    if (typeof content.content === "string") return content.content;
+  }
+  return "";
+}
+
+function extractClaudeRecord(record = {}, fallback = {}) {
+  const sessionId = fallback.sessionId || record.sessionId || record.session_id || "";
+  const timestamp = record.timestamp || record.ts || record.created_at || fallback.ts || "";
+  const type = String(record.type || record.role || "").toLowerCase();
+  const role = type === "assistant" ? "assistant" : (type === "user" ? "user" : String(record.role || type || ""));
+  const message = record.message && typeof record.message === "object" ? record.message : record;
+  const text = extractContent(message.content || record.content || record.text || record.display);
+  let toolName = "";
+  const content = message.content || record.content;
+  if (Array.isArray(content)) {
+    const toolUse = content.find((item) => item && item.type === "tool_use");
+    if (toolUse) toolName = String(toolUse.name || "");
+  }
+  if (!text) return null;
+  return {
+    source: "claude-code",
+    session_id: String(sessionId || ""),
+    ts: timestamp ? String(timestamp) : "",
+    role: role || "unknown",
+    text,
+    ...(toolName ? { tool_name: toolName } : {}),
+    file: fallback.file || "",
+  };
+}
+
+function extractCodexRecord(record = {}, fallback = {}) {
+  if (record.type === "session_meta") return { sessionMeta: record.payload || {} };
+  const sessionId = fallback.sessionId || record.session_id || record.sessionId || "";
+  const timestamp = record.timestamp || record.ts || record.created_at || fallback.ts || "";
+  if (record.type === "message" || record.role) {
+    const text = extractContent(record.content || record.message || record.text);
+    if (!text) return null;
+    return {
+      source: "codex",
+      session_id: String(sessionId || ""),
+      ts: timestamp ? String(timestamp) : "",
+      role: String(record.role || "unknown"),
+      text,
+      file: fallback.file || "",
+    };
+  }
+  const item = record.item || record.payload || {};
+  if (item && item.type === "tool_call") {
+    return {
+      source: "codex",
+      session_id: String(sessionId || ""),
+      ts: timestamp ? String(timestamp) : "",
+      role: "tool",
+      text: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments || {}),
+      tool_name: String(item.name || ""),
+      file: fallback.file || "",
+    };
+  }
+  const text = extractContent(record.display || record.prompt || record.input || record.message || record.text || record.content);
+  if (!text) return null;
+  return {
+    source: "codex",
+    session_id: String(sessionId || ""),
+    ts: timestamp ? String(timestamp) : "",
+    role: String(record.role || "unknown"),
+    text,
+    file: fallback.file || "",
+  };
+}
+
+function scoreSnippet(snippet, tokens) {
+  const haystack = [
+    snippet.session_id,
+    snippet.role,
+    snippet.tool_name || "",
+    snippet.text,
+  ].join(" ").toLowerCase();
+  let score = 0;
+  for (const token of tokens) {
+    if (haystack.includes(token)) score += 1;
+    if (String(snippet.text || "").toLowerCase().includes(token)) score += 2;
+  }
+  return score;
+}
+
+function discoverHistoryFiles(projectRoot, options = {}) {
+  const home = getHomeDir(options);
+  const agent = normalizeAgent(options.agent);
+  const files = [];
+  if (!agent || agent === "claude-code") {
+    const claudeProjectDir = options.claudeProjectDir
+      || path.join(home, ".claude", "projects", normalizeProjectSlug(projectRoot));
+    if (fs.existsSync(claudeProjectDir)) {
+      files.push(...walkFiles(claudeProjectDir, (filePath, name) => name.endsWith(".jsonl"))
+        .map((file) => ({ agent: "claude-code", file })));
+    }
+    const claudeHistoryFile = options.claudeHistoryFile || path.join(home, ".claude", "history.jsonl");
+    if (fs.existsSync(claudeHistoryFile)) files.push({ agent: "claude-code", file: claudeHistoryFile });
+  }
+  if (!agent || agent === "codex") {
+    const codexSessionsDir = options.codexSessionsDir || path.join(home, ".codex", "sessions");
+    if (fs.existsSync(codexSessionsDir)) {
+      files.push(...walkFiles(codexSessionsDir, (filePath, name) => name.endsWith(".jsonl"))
+        .map((file) => ({ agent: "codex", file })));
+    }
+    const codexHistoryFile = options.codexHistoryFile || path.join(home, ".codex", "history.jsonl");
+    if (fs.existsSync(codexHistoryFile)) files.push({ agent: "codex", file: codexHistoryFile });
+  }
+  return files;
+}
+
+function readSnippetsFromFile({ agent, file }, options = {}) {
+  const records = safeReadJsonl(file);
+  let sessionId = String(options.sessionId || path.basename(file, ".jsonl")).trim();
+  const snippets = [];
+  const statTs = (() => {
+    try { return fs.statSync(file).mtime.toISOString(); } catch { return ""; }
+  })();
+
+  for (const record of records) {
+    if (agent === "codex") {
+      const extracted = extractCodexRecord(record, { file, sessionId, ts: statTs });
+      if (extracted && extracted.sessionMeta) {
+        sessionId = String(extracted.sessionMeta.id || sessionId || "");
+        continue;
+      }
+      if (extracted) {
+        extracted.session_id = extracted.session_id || sessionId;
+        snippets.push(extracted);
+      }
+    } else {
+      const extracted = extractClaudeRecord(record, { file, sessionId, ts: statTs });
+      if (extracted) snippets.push(extracted);
+    }
+  }
+  return snippets;
+}
+
+function applyRedaction(snippet) {
+  const safe = redactSecrets({
+    source: snippet.source,
+    session_id: snippet.session_id,
+    ts: snippet.ts,
+    role: snippet.role,
+    text: redactString(snippet.text),
+    ...(snippet.tool_name ? { tool_name: snippet.tool_name } : {}),
+  });
+  return safe;
+}
+
+function searchHistory(projectRoot, args = {}, options = {}) {
+  const query = String(args.query || "").trim();
+  if (!query) {
+    const err = new Error("search_history requires query");
+    err.code = "invalid_history_query";
+    throw err;
+  }
+  const tokens = tokenize(query);
+  const limit = Math.min(
+    MAX_RESULTS,
+    Number.isFinite(Number(args.limit)) && Number(args.limit) > 0
+      ? Math.floor(Number(args.limit))
+      : MAX_RESULTS
+  );
+  const requestedSession = String(args.session_id || args.sessionId || "").trim();
+  const files = discoverHistoryFiles(projectRoot, {
+    ...options,
+    agent: args.agent,
+  });
+
+  const scored = [];
+  for (const fileInfo of files) {
+    const snippets = readSnippetsFromFile(fileInfo, { sessionId: requestedSession });
+    for (const snippet of snippets) {
+      if (requestedSession && snippet.session_id !== requestedSession) continue;
+      const score = scoreSnippet(snippet, tokens);
+      if (score <= 0) continue;
+      scored.push({ snippet, score });
+    }
+  }
+
+  scored.sort((a, b) => b.score - a.score || String(b.snippet.ts || "").localeCompare(String(a.snippet.ts || "")));
+  const results = [];
+  let totalText = 0;
+  for (const item of scored) {
+    if (results.length >= limit) break;
+    const safe = applyRedaction(item.snippet);
+    const remaining = Math.max(0, MAX_TOTAL_TEXT_CHARS - totalText);
+    if (remaining <= 0) break;
+    if (safe.text.length > remaining) safe.text = `${safe.text.slice(0, remaining)}...[truncated]`;
+    totalText += safe.text.length;
+    results.push(safe);
+  }
+
+  return {
+    ok: true,
+    from_history: true,
+    query,
+    count: results.length,
+    snippets: results,
+  };
+}
+
+module.exports = {
+  MAX_RESULTS,
+  MAX_TOTAL_TEXT_CHARS,
+  normalizeAgent,
+  searchHistory,
+  discoverHistoryFiles,
+  readSnippetsFromFile,
+};