u-foo 1.0.6 → 1.1.9

package/src/chat/commands.js

@@ -0,0 +1,132 @@
+const COMMAND_TREE = {
+  "/bus": {
+    desc: "Event bus operations",
+    children: {
+      activate: { desc: "Activate agent terminal" },
+      list: { desc: "List all agents" },
+      rename: { desc: "Rename agent nickname" },
+      send: { desc: "Send message to agent" },
+      status: { desc: "Bus status" },
+    },
+  },
+  "/ctx": {
+    desc: "Context management",
+    children: {
+      decisions: { desc: "List all decisions" },
+      doctor: { desc: "Check context integrity" },
+      status: { desc: "Show context status (default)" },
+    },
+  },
+  "/daemon": {
+    desc: "Daemon management",
+    children: {
+      restart: { desc: "Restart daemon" },
+      start: { desc: "Start daemon" },
+      status: { desc: "Daemon status" },
+      stop: { desc: "Stop daemon" },
+    },
+  },
+  "/doctor": { desc: "Health check diagnostics" },
+  "/corn": {
+    desc: "Cron scheduler operations",
+    children: {
+      start: { desc: "Create cron task" },
+      list: { desc: "List cron tasks" },
+      stop: { desc: "Stop cron task by id or all" },
+    },
+  },
+  "/init": { desc: "Initialize modules" },
+  "/launch": {
+    desc: "Launch new agent",
+    children: {
+      claude: { desc: "Launch Claude agent" },
+      codex: { desc: "Launch Codex agent" },
+      ucode: { desc: "Launch ucode core agent" },
+    },
+  },
+  "/resume": {
+    desc: "Resume agents (optional nickname) or list recoverable targets",
+    children: {
+      list: { desc: "List recoverable agents (optional target)" },
+    },
+  },
+  "/settings": {
+    desc: "Settings operations",
+    children: {
+      ucode: { desc: "Manage ucode model provider config" },
+    },
+  },
+  "/skills": {
+    desc: "Skills management",
+    children: {
+      install: { desc: "Install skills (use: all or name)" },
+      list: { desc: "List available skills" },
+    },
+  },
+  "/status": { desc: "Status display" },
+};
+
+const COMMAND_ORDER = ["/launch", "/bus", "/ctx"];
+const COMMAND_ORDER_MAP = new Map(COMMAND_ORDER.map((cmd, idx) => [cmd, idx]));
+
+function sortCommands(a, b) {
+  const ai = COMMAND_ORDER_MAP.has(a) ? COMMAND_ORDER_MAP.get(a) : Number.POSITIVE_INFINITY;
+  const bi = COMMAND_ORDER_MAP.has(b) ? COMMAND_ORDER_MAP.get(b) : Number.POSITIVE_INFINITY;
+  if (ai !== bi) return ai - bi;
+  return a.localeCompare(b, "en", { sensitivity: "base" });
+}
+
+function buildCommandRegistry(tree) {
+  return Object.keys(tree)
+    .sort(sortCommands)
+    .map((cmd) => {
+      const node = tree[cmd] || {};
+      const entry = { cmd, desc: node.desc || "" };
+      if (node.children) {
+        entry.subcommands = Object.keys(node.children)
+          .sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" }))
+          .map((sub) => ({
+            cmd: sub,
+            desc: (node.children[sub] && node.children[sub].desc) || "",
+          }));
+      }
+      return entry;
+    });
+}
+
+const COMMAND_REGISTRY = buildCommandRegistry(COMMAND_TREE);
+
+function parseCommand(text) {
+  if (!text.startsWith("/")) return null;
+
+  // Split by whitespace, respecting quotes
+  const parts = text.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+  if (parts.length === 0) return null;
+
+  const command = parts[0].slice(1); // Remove leading /
+  const args = parts.slice(1).map((arg) => arg.replace(/^"|"$/g, "")); // Remove quotes
+
+  return { command, args };
+}
+
+function parseAtTarget(text) {
+  if (!text.startsWith("@")) return null;
+  const trimmed = text.slice(1).trim();
+  if (!trimmed) return null;
+  const spaceIdx = trimmed.indexOf(" ");
+  if (spaceIdx === -1) {
+    return { target: trimmed, message: "" };
+  }
+  const target = trimmed.slice(0, spaceIdx).trim();
+  const message = trimmed.slice(spaceIdx + 1).trim();
+  return { target, message };
+}
+
+module.exports = {
+  COMMAND_TREE,
+  COMMAND_REGISTRY,
+  sortCommands,
+  buildCommandRegistry,
+  parseCommand,
+  parseAtTarget,
+};

package/src/chat/completionController.js

@@ -0,0 +1,414 @@
+const FALLBACK_LAUNCH_SUBCOMMANDS = [
+  { cmd: "claude", desc: "Launch Claude agent" },
+  { cmd: "codex", desc: "Launch Codex agent" },
+  { cmd: "ucode", desc: "Launch ucode core agent" },
+];
+
+function createCompletionController(options = {}) {
+  const {
+    input,
+    screen,
+    completionPanel,
+    promptBox,
+    commandRegistry = [],
+    getMentionCandidates = () => [],
+    normalizeCommandPrefix = () => {},
+    truncateText = (text) => String(text || ""),
+    getCurrentInputHeight = () => 4,
+    getCursorPos = () => 0,
+    setCursorPos = () => {},
+    resetPreferredCol = () => {},
+    updateDraftFromInput = () => {},
+    renderScreen = () => {},
+    setImmediateFn = setImmediate,
+    clearImmediateFn = clearImmediate,
+  } = options;
+
+  if (!input || !screen || !completionPanel || !promptBox) {
+    throw new Error("createCompletionController requires input/screen/completionPanel/promptBox");
+  }
+
+  const state = {
+    active: false,
+    commands: [],
+    index: 0,
+    scrollOffset: 0,
+    visibleCount: 0,
+    enterSuppressed: false,
+    enterReset: null,
+  };
+
+  function setPanelLayout() {
+    const availableHeight = Math.max(1, screen.height - getCurrentInputHeight() - 1);
+    const maxVisible = Math.max(1, availableHeight - 2);
+    state.visibleCount = Math.min(7, state.commands.length, maxVisible);
+    completionPanel.height = Math.min(availableHeight, state.visibleCount + 2);
+    completionPanel.bottom = getCurrentInputHeight() - 1;
+  }
+
+  function render() {
+    if (!state.active || state.commands.length === 0) return;
+
+    const panelVisible = Math.max(1, (completionPanel.height || 1) - 2);
+    const maxVisible = state.visibleCount
+      ? Math.max(1, Math.min(state.visibleCount, panelVisible))
+      : panelVisible;
+
+    if (state.index < state.scrollOffset) {
+      state.scrollOffset = state.index;
+    } else if (state.index >= state.scrollOffset + maxVisible) {
+      state.scrollOffset = state.index - maxVisible + 1;
+    }
+
+    const visibleStart = state.scrollOffset;
+    const visibleEnd = Math.min(state.scrollOffset + maxVisible, state.commands.length);
+    const visibleCommands = state.commands.slice(visibleStart, visibleEnd);
+
+    const panelWidth = typeof completionPanel.width === "number"
+      ? completionPanel.width
+      : screen.width;
+
+    const lines = visibleCommands.map((item, i) => {
+      const actualIndex = visibleStart + i;
+      const cmdText = item.cmd;
+      const descText = item.desc || "";
+      const cmdPart = actualIndex === state.index
+        ? `{inverse}${cmdText}{/inverse}`
+        : `{cyan-fg}${cmdText}{/cyan-fg}`;
+      const indent = " ".repeat(promptBox.width || 2);
+      const maxDescWidth = Math.max(0, panelWidth - indent.length - cmdText.length - 2);
+      const trimmedDesc = truncateText(descText, maxDescWidth);
+      const descPart = trimmedDesc ? `{gray-fg}${trimmedDesc}{/gray-fg}` : "";
+      return descPart ? `${indent}${cmdPart}  ${descPart}` : `${indent}${cmdPart}`;
+    });
+
+    completionPanel.setContent(lines.join("\n"));
+    renderScreen();
+  }
+
+  function hide() {
+    state.active = false;
+    state.commands = [];
+    state.index = 0;
+    state.scrollOffset = 0;
+    state.visibleCount = 0;
+    completionPanel.hidden = true;
+    renderScreen();
+  }
+
+  function buildCommands(filterText) {
+    const mentionMatch = String(filterText || "").match(/^@([^\s]*)$/);
+    if (mentionMatch) {
+      const mentionFilter = String(mentionMatch[1] || "").trim().toLowerCase();
+      const rawCandidates = Array.isArray(getMentionCandidates()) ? getMentionCandidates() : [];
+      const seen = new Set();
+      const items = [];
+      for (const item of rawCandidates) {
+        const id = String(item && item.id ? item.id : "").trim();
+        const label = String(item && item.label ? item.label : id).trim();
+        if (!id && !label) continue;
+        const rawToken = label || id;
+        const normalizedToken = rawToken.replace(/^@+/, "");
+        if (!normalizedToken || /\s/.test(normalizedToken)) continue;
+        const tokenLower = normalizedToken.toLowerCase();
+        const idLower = id.toLowerCase();
+        if (
+          mentionFilter
+          && !tokenLower.startsWith(mentionFilter)
+          && !idLower.startsWith(mentionFilter)
+        ) {
+          continue;
+        }
+        if (seen.has(normalizedToken)) continue;
+        seen.add(normalizedToken);
+        const desc = id && id !== normalizedToken ? id : "";
+        items.push({
+          cmd: `@${normalizedToken}`,
+          desc,
+          isMention: true,
+          mentionTarget: normalizedToken,
+        });
+      }
+      return items.sort((a, b) => a.cmd.localeCompare(b.cmd));
+    }
+
+    const endsWithSpace = /\s$/.test(filterText);
+    const trimmed = filterText.trim();
+    if (!trimmed) {
+      return [];
+    }
+
+    const parts = trimmed.split(/\s+/);
+    const mainCmd = parts[0];
+    const isLaunch = mainCmd && mainCmd.toLowerCase() === "/launch";
+    const wantsSubcommands = (parts.length > 1 || (endsWithSpace && parts.length === 1));
+
+    if ((wantsSubcommands || isLaunch) && mainCmd && mainCmd.startsWith("/")) {
+      const subFilter = parts[1] || "";
+      const mainCmdObj = commandRegistry.find((item) =>
+        item.cmd.toLowerCase() === mainCmd.toLowerCase()
+      );
+      if ((mainCmdObj && mainCmdObj.subcommands) || isLaunch) {
+        const baseSubs = mainCmdObj && mainCmdObj.subcommands ? mainCmdObj.subcommands : [];
+        let subs = baseSubs;
+        if (isLaunch) {
+          const merged = new Map();
+          for (const sub of [...baseSubs, ...FALLBACK_LAUNCH_SUBCOMMANDS]) {
+            if (!sub || !sub.cmd) continue;
+            merged.set(sub.cmd, sub);
+          }
+          subs = Array.from(merged.values());
+        }
+        if (isLaunch) {
+          return subs
+            .map((sub) => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }))
+            .sort((a, b) => a.cmd.localeCompare(b.cmd));
+        }
+        return subs
+          .filter((sub) => sub.cmd.toLowerCase().startsWith(subFilter.toLowerCase()))
+          .map((sub) => ({ ...sub, isSubcommand: true, parentCmd: mainCmd }))
+          .sort((a, b) => a.cmd.localeCompare(b.cmd));
+      }
+      return [];
+    }
+
+    const filterLower = trimmed.toLowerCase();
+    return commandRegistry.filter((item) => item.cmd.toLowerCase().startsWith(filterLower));
+  }
+
+  function show(filterText) {
+    normalizeCommandPrefix();
+
+    let nextFilter = filterText;
+    if (nextFilter !== input.value) {
+      nextFilter = input.value;
+    }
+
+    if (nextFilter.startsWith("//")) {
+      nextFilter = nextFilter.replace(/^\/+/, "/");
+      input.value = nextFilter;
+      setCursorPos(Math.min(getCursorPos(), input.value.length));
+    }
+
+    if (!nextFilter) {
+      hide();
+      return;
+    }
+
+    const commands = buildCommands(nextFilter);
+    if (commands.length === 0) {
+      hide();
+      return;
+    }
+
+    state.commands = commands;
+    state.active = true;
+    state.index = 0;
+    state.scrollOffset = 0;
+    setPanelLayout();
+    completionPanel.hidden = false;
+    render();
+  }
+
+  function pageSize() {
+    const panelVisible = Math.max(1, (completionPanel.height || 2) - 2);
+    return state.visibleCount
+      ? Math.max(1, Math.min(state.visibleCount, panelVisible))
+      : panelVisible;
+  }
+
+  function up() {
+    if (state.commands.length === 0) return;
+    state.index = state.index <= 0 ? state.commands.length - 1 : state.index - 1;
+    render();
+  }
+
+  function down() {
+    if (state.commands.length === 0) return;
+    state.index = state.index >= state.commands.length - 1 ? 0 : state.index + 1;
+    render();
+  }
+
+  function pageUp() {
+    if (state.commands.length === 0) return;
+    state.index = Math.max(0, state.index - pageSize());
+    render();
+  }
+
+  function pageDown() {
+    if (state.commands.length === 0) return;
+    state.index = Math.min(state.commands.length - 1, state.index + pageSize());
+    render();
+  }
+
+  function preview(selected) {
+    const current = input.value || "";
+    const trimmed = current.trim();
+    const endsWithSpace = /\s$/.test(current);
+
+    if (selected.isMention) {
+      const mentionTarget = String(selected.mentionTarget || selected.cmd || "").replace(/^@+/, "");
+      const completedCore = `@${mentionTarget}`;
+      const isComplete = (trimmed === completedCore && endsWithSpace) || trimmed.startsWith(`${completedCore} `);
+      return { text: `${completedCore} `, isComplete };
+    }
+
+    if (selected.isSubcommand) {
+      const parts = trimmed.split(/\s+/);
+      const base = parts[0] || "";
+      const completedCore = base ? `${base} ${selected.cmd}` : selected.cmd;
+      const isComplete = trimmed === completedCore || trimmed.startsWith(`${completedCore} `);
+      return { text: `${completedCore} `, isComplete };
+    }
+
+    const completedCore = selected.cmd;
+    const hasChildren = selected.subcommands && selected.subcommands.length > 0;
+    const isComplete =
+      (trimmed === completedCore && (!hasChildren || endsWithSpace)) ||
+      trimmed.startsWith(`${completedCore} `);
+    return { text: `${completedCore} `, isComplete };
+  }
+
+  function applyPreview(nextPreview) {
+    input.value = nextPreview.text;
+    setCursorPos(input.value.length);
+    resetPreferredCol();
+    if (typeof input._updateCursor === "function") {
+      input._updateCursor();
+    }
+    updateDraftFromInput();
+    renderScreen();
+  }
+
+  function confirm() {
+    if (!state.active || state.commands.length === 0) return;
+
+    const selected = state.commands[state.index];
+    if (selected.isMention) {
+      const mentionTarget = String(selected.mentionTarget || selected.cmd || "").replace(/^@+/, "");
+      input.value = `@${mentionTarget} `;
+    } else if (selected.isSubcommand) {
+      const parts = input.value.split(/\s+/);
+      parts[parts.length - 1] = selected.cmd;
+      input.value = `${parts.join(" ")} `;
+    } else {
+      input.value = `${selected.cmd} `;
+    }
+
+    setCursorPos(input.value.length);
+    resetPreferredCol();
+    if (typeof input._updateCursor === "function") {
+      input._updateCursor();
+    }
+    updateDraftFromInput();
+
+    if (!selected.isSubcommand && selected.subcommands && selected.subcommands.length > 0) {
+      show(input.value);
+    } else {
+      hide();
+    }
+
+    renderScreen();
+  }
+
+  function handleKey(ch, key = {}) {
+    if (!state.active) return false;
+
+    if (key.name === "up") {
+      up();
+      return true;
+    }
+    if (key.name === "down") {
+      down();
+      return true;
+    }
+    if (key.name === "tab") {
+      confirm();
+      return true;
+    }
+    if (key.name === "pageup") {
+      pageUp();
+      return true;
+    }
+    if (key.name === "pagedown") {
+      pageDown();
+      return true;
+    }
+
+    if (key.name === "enter" || key.name === "return") {
+      if (state.enterSuppressed) {
+        return true;
+      }
+      const selected = state.commands[state.index];
+      if (selected) {
+        const nextPreview = preview(selected);
+        if (!nextPreview.isComplete) {
+          applyPreview(nextPreview);
+          if (!selected.isSubcommand && selected.subcommands && selected.subcommands.length > 0) {
+            show(input.value);
+          } else {
+            hide();
+          }
+          state.enterSuppressed = true;
+          if (state.enterReset) clearImmediateFn(state.enterReset);
+          state.enterReset = setImmediateFn(() => {
+            state.enterSuppressed = false;
+          });
+          return true;
+        }
+      }
+      hide();
+      state.enterSuppressed = true;
+      if (state.enterReset) clearImmediateFn(state.enterReset);
+      state.enterReset = setImmediateFn(() => {
+        state.enterSuppressed = false;
+      });
+      return false;
+    }
+
+    if (key.name === "escape") {
+      hide();
+      return true;
+    }
+
+    if (ch === " ") {
+      const currentInput = (input.value || "").trim();
+      if (currentInput.startsWith("/") && !currentInput.includes(" ")) {
+        return false;
+      }
+      if (currentInput.startsWith("@") && !currentInput.includes(" ")) {
+        return false;
+      }
+      hide();
+      return false;
+    }
+
+    return false;
+  }
+
+  function reflow() {
+    if (!state.active) return;
+    setPanelLayout();
+    render();
+  }
+
+  function jumpToLast() {
+    if (state.commands.length === 0) return;
+    state.index = state.commands.length - 1;
+    render();
+  }
+
+  return {
+    show,
+    hide,
+    handleKey,
+    reflow,
+    isActive: () => state.active,
+    getCommandCount: () => state.commands.length,
+    jumpToLast,
+  };
+}
+
+module.exports = {
+  createCompletionController,
+};

package/src/chat/cronScheduler.js

@@ -0,0 +1,160 @@
+function parseIntervalMs(value = "") {
+  const text = String(value || "").trim().toLowerCase();
+  if (!text) return 0;
+  const match = text.match(/^(\d+)(ms|s|m|h)?$/);
+  if (!match) return 0;
+  const amount = Number.parseInt(match[1], 10);
+  if (!Number.isFinite(amount) || amount <= 0) return 0;
+  const unit = match[2] || "s";
+  if (unit === "ms") return amount;
+  if (unit === "s") return amount * 1000;
+  if (unit === "m") return amount * 60 * 1000;
+  if (unit === "h") return amount * 60 * 60 * 1000;
+  return 0;
+}
+
+function formatIntervalMs(ms = 0) {
+  const value = Number(ms) || 0;
+  if (value <= 0) return "0s";
+  if (value % (60 * 60 * 1000) === 0) return `${value / (60 * 60 * 1000)}h`;
+  if (value % (60 * 1000) === 0) return `${value / (60 * 1000)}m`;
+  if (value % 1000 === 0) return `${value / 1000}s`;
+  return `${value}ms`;
+}
+
+function sanitizeSummaryText(value = "") {
+  return String(value || "")
+    .replace(/[{}]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function summarizeTask(task = {}) {
+  const id = String(task.id || "");
+  const interval = formatIntervalMs(task.intervalMs || 0);
+  const targets = Array.isArray(task.targets) ? task.targets.join("+") : "";
+  const promptRaw = sanitizeSummaryText(task.prompt || "");
+  const prompt = promptRaw.length > 24 ? `${promptRaw.slice(0, 24)}...` : promptRaw;
+  return `${id}@${interval}->${targets}: ${prompt || "(empty)"}`;
+}
+
+function createCronScheduler(options = {}) {
+  const {
+    dispatch = () => {},
+    onChange = () => {},
+    setIntervalFn = setInterval,
+    clearIntervalFn = clearInterval,
+    nowFn = () => Date.now(),
+  } = options;
+
+  let seq = 0;
+  const tasks = [];
+
+  function notifyChange() {
+    try {
+      onChange();
+    } catch {
+      // ignore observer errors
+    }
+  }
+
+  function addTask({ intervalMs = 0, targets = [], prompt = "" } = {}) {
+    const safeInterval = Number.parseInt(intervalMs, 10);
+    const safeTargets = Array.isArray(targets)
+      ? targets.map((item) => String(item || "").trim()).filter(Boolean)
+      : [];
+    const safePrompt = String(prompt || "").trim();
+    if (!Number.isFinite(safeInterval) || safeInterval <= 0) return null;
+    if (safeTargets.length === 0) return null;
+    if (!safePrompt) return null;
+
+    const id = `c${++seq}`;
+    const task = {
+      id,
+      intervalMs: safeInterval,
+      targets: Array.from(new Set(safeTargets)),
+      prompt: safePrompt,
+      createdAt: nowFn(),
+      lastRunAt: 0,
+      tickCount: 0,
+      timer: null,
+    };
+
+    task.timer = setIntervalFn(() => {
+      task.lastRunAt = nowFn();
+      task.tickCount += 1;
+      for (const target of task.targets) {
+        try {
+          dispatch({
+            taskId: task.id,
+            target,
+            message: task.prompt,
+          });
+        } catch {
+          // ignore single-dispatch errors
+        }
+      }
+    }, task.intervalMs);
+
+    tasks.push(task);
+    notifyChange();
+    return {
+      ...task,
+      summary: summarizeTask(task),
+    };
+  }
+
+  function listTasks() {
+    return tasks.map((task) => ({
+      id: task.id,
+      intervalMs: task.intervalMs,
+      targets: task.targets.slice(),
+      prompt: task.prompt,
+      createdAt: task.createdAt,
+      lastRunAt: task.lastRunAt,
+      tickCount: task.tickCount,
+      summary: summarizeTask(task),
+    }));
+  }
+
+  function stopTask(taskId = "") {
+    const id = String(taskId || "").trim();
+    if (!id) return false;
+    const idx = tasks.findIndex((task) => task.id === id);
+    if (idx < 0) return false;
+    const task = tasks[idx];
+    if (task && task.timer) {
+      clearIntervalFn(task.timer);
+    }
+    tasks.splice(idx, 1);
+    notifyChange();
+    return true;
+  }
+
+  function stopAll() {
+    if (tasks.length === 0) return 0;
+    const count = tasks.length;
+    while (tasks.length > 0) {
+      const task = tasks.pop();
+      if (task && task.timer) {
+        clearIntervalFn(task.timer);
+      }
+    }
+    notifyChange();
+    return count;
+  }
+
+  return {
+    addTask,
+    listTasks,
+    stopTask,
+    stopAll,
+  };
+}
+
+module.exports = {
+  parseIntervalMs,
+  formatIntervalMs,
+  summarizeTask,
+  createCronScheduler,
+};