u-foo 1.0.0

package/scripts/skills.sh

@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+skill_roots=()
+if [[ -d "$repo_root/SKILLS" ]]; then
+  skill_roots+=("$repo_root/SKILLS")
+fi
+if [[ -d "$repo_root/modules" ]]; then
+  while IFS= read -r d; do
+    skill_roots+=("$d")
+  done < <(find "$repo_root/modules" -maxdepth 2 -type d -name SKILLS | sort)
+fi
+
+usage() {
+  cat <<'EOFU'
+skills
+
+Usage:
+  ufoo skills list
+  ufoo skills install <name|all> [--target <dir> | --codex | --agents]
+EOFU
+}
+
+cmd="${1:-}"
+shift || true
+
+case "$cmd" in
+  list)
+    for root in "${skill_roots[@]}"; do
+      find "$root" -mindepth 1 -maxdepth 1 -type d -print
+    done | sed 's|.*/||' | sort -u
+    ;;
+  install)
+    name="${1:-}"
+    shift || true
+    if [[ -z "$name" ]]; then
+      echo "FAIL: install requires <name|all>" >&2
+      exit 1
+    fi
+
+    target=""
+    while [[ $# -gt 0 ]]; do
+      case "$1" in
+        --target)
+          target="$2"; shift 2 ;;
+        --codex)
+          target="${CODEX_HOME:-$HOME/.codex}/skills"; shift ;;
+        --agents)
+          target="$HOME/.agents/skills"; shift ;;
+        *)
+          echo "Unknown option: $1" >&2
+          usage >&2
+          exit 1
+          ;;
+      esac
+    done
+
+    if [[ -z "$target" ]]; then
+      echo "FAIL: specify --target/--codex/--agents" >&2
+      exit 1
+    fi
+
+    mkdir -p "$target"
+
+    find_skill() {
+      local skill_name="$1"
+      local matches=()
+      local root
+      for root in "${skill_roots[@]}"; do
+        if [[ -f "$root/$skill_name/SKILL.md" ]]; then
+          matches+=("$root/$skill_name")
+        fi
+      done
+      if (( ${#matches[@]} == 0 )); then
+        echo "FAIL: missing skill '$skill_name'" >&2
+        exit 1
+      fi
+      if (( ${#matches[@]} > 1 )); then
+        echo "FAIL: duplicate skill name '$skill_name' in:" >&2
+        printf '  - %s\n' "${matches[@]}" >&2
+        exit 1
+      fi
+      echo "${matches[0]}"
+    }
+
+    install_one() {
+      local skill_name="$1"
+      local src_dir
+      src_dir="$(find_skill "$skill_name")"
+      local src_file="$src_dir/SKILL.md"
+      local dst_dir="$target/$skill_name"
+      local dst_file="$dst_dir/SKILL.md"
+
+      mkdir -p "$dst_dir"
+      cp "$src_file" "$dst_file"
+      echo "Installed: $skill_name"
+    }
+
+    if [[ "$name" == "all" ]]; then
+      while IFS= read -r d; do
+        install_one "$d"
+      done < <(for root in "${skill_roots[@]}"; do find "$root" -mindepth 1 -maxdepth 1 -type d -print; done | sed 's|.*/||' | sort -u)
+    else
+      install_one "$name"
+    fi
+    ;;
+  *)
+    usage
+    exit 1
+    ;;
+esac

package/scripts/status.sh

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ ! -d ".ufoo" ]]; then
+  echo "FAIL: .ufoo not found. Run: ufoo init" >&2
+  exit 1
+fi
+
+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+if [[ -f "$repo_root/scripts/banner.sh" ]]; then
+  # shellcheck disable=SC1090
+  source "$repo_root/scripts/banner.sh"
+fi
+
+agent_type="claude"
+session_id="${CLAUDE_SESSION_ID:-}"
+if [[ -n "${CODEX_SESSION_ID:-}" ]]; then
+  agent_type="codex"
+  session_id="$CODEX_SESSION_ID"
+fi
+
+subscriber=""
+if [[ -f ".ufoo/bus/bus.json" ]]; then
+  cur_tty="$(tty 2>/dev/null || true)"
+  if [[ "$cur_tty" == /dev/* ]]; then
+    subscriber="$(
+      jq -r --arg tty "$cur_tty" \
+        '.subscribers | to_entries[] | select(.value.tty == $tty) | .key' \
+        .ufoo/bus/bus.json 2>/dev/null | head -1
+    )"
+  fi
+fi
+
+if [[ -z "$subscriber" && -n "$session_id" ]]; then
+  if [[ "$agent_type" == "codex" ]]; then
+    subscriber="codex:$session_id"
+  else
+    subscriber="claude-code:$session_id"
+  fi
+fi
+
+if [[ -z "$session_id" && "$subscriber" == *:* ]]; then
+  session_id="${subscriber#*:}"
+fi
+if [[ -z "$session_id" ]]; then
+  session_id="unknown"
+fi
+
+if declare -F show_banner >/dev/null 2>&1; then
+  show_banner "$agent_type" "$session_id" "$subscriber"
+else
+  echo "=== ufoo status ==="
+  echo "Agent: ${subscriber:-$agent_type}"
+  echo ""
+fi
+
+echo "Project: $(pwd)"
+
+unread_total=0
+unread_lines=""
+if [[ -d ".ufoo/bus/queues" ]]; then
+  shopt -s nullglob
+  for queue_file in .ufoo/bus/queues/*/pending.jsonl; do
+    [[ -s "$queue_file" ]] || continue
+    count=$(wc -l < "$queue_file" | tr -d ' ')
+    unread_total=$((unread_total + count))
+    safe_name="$(basename "$(dirname "$queue_file")")"
+    subscriber_name="$safe_name"
+    if [[ -f ".ufoo/bus/bus.json" ]]; then
+      subscriber_name="$(
+        jq -r --arg safe "$safe_name" \
+          '.subscribers | to_entries[] | select((.key|gsub(":";"_")) == $safe) | .key' \
+          .ufoo/bus/bus.json 2>/dev/null | head -1
+      )"
+      [[ -n "$subscriber_name" && "$subscriber_name" != "null" ]] || subscriber_name="$safe_name"
+    else
+      subscriber_name="${safe_name/_/:}"
+    fi
+    unread_lines+=$'  - '"$subscriber_name"$': '"$count"$'\n'
+  done
+  shopt -u nullglob
+fi
+
+echo "Unread messages: $unread_total"
+if [[ -n "$unread_lines" ]]; then
+  printf "%s" "$unread_lines"
+fi
+
+decisions_dir=".ufoo/context/DECISIONS"
+open_count=0
+open_lines=""
+
+get_status() {
+  local file="$1"
+  local status
+  if grep -q "^---$" "$file"; then
+    status=$(awk '/^---$/{if(++c==2)exit} c==1 && /^status:/{print $2}' "$file")
+  fi
+  echo "${status:-open}"
+}
+
+get_title() {
+  awk '/^#/{sub(/^# */,"");print; exit}' "$1"
+}
+
+if [[ -d "$decisions_dir" ]]; then
+  shopt -s nullglob
+  for f in "$decisions_dir"/*.md; do
+    [[ -f "$f" ]] || continue
+    status="$(get_status "$f")"
+    if [[ "$status" == "open" ]]; then
+      open_count=$((open_count + 1))
+      title="$(get_title "$f")"
+      [[ -z "$title" ]] && title="(no title)"
+      open_lines+=$'  - '"$(basename "$f")"$': '"$title"$'\n'
+    fi
+  done
+  shopt -u nullglob
+fi
+
+echo "Open decisions: $open_count"
+if [[ -n "$open_lines" ]]; then
+  printf "%s" "$open_lines"
+fi

package/src/agent/cliRunner.js

@@ -0,0 +1,190 @@
+const { spawn } = require("child_process");
+const { randomUUID } = require("crypto");
+
+function collectJsonl(text) {
+  const lines = text.split(/\r?\n/).filter((l) => l.trim());
+  const items = [];
+  for (const line of lines) {
+    try {
+      items.push(JSON.parse(line));
+    } catch {
+      // Ignore malformed lines
+    }
+  }
+  return items;
+}
+
+function collectJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      ...options,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString("utf8");
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString("utf8");
+    });
+    let timeout = null;
+    if (options.timeoutMs) {
+      timeout = setTimeout(() => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+          // ignore
+        }
+        reject(new Error("CLI timeout"));
+      }, options.timeoutMs);
+    }
+
+    child.on("error", (err) => {
+      if (timeout) clearTimeout(timeout);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (timeout) clearTimeout(timeout);
+      resolve({ code, stdout, stderr });
+    });
+
+    if (options.input) {
+      child.stdin.write(options.input);
+    }
+    child.stdin.end();
+  });
+}
+
+const DEFAULT_CLAUDE = {
+  command: "claude",
+  args: [
+    "-p",
+    "--output-format",
+    "json",
+    "--dangerously-skip-permissions",
+    "--no-session-persistence",
+    "--json-schema",
+    '{"type":"object","properties":{"reply":{"type":"string"},"dispatch":{"type":"array","items":{"type":"object","properties":{"target":{"type":"string"},"message":{"type":"string"}},"required":["target","message"]}},"ops":{"type":"array","items":{"type":"object","properties":{"action":{"type":"string"},"agent":{"type":"string"},"count":{"type":"integer"},"agent_id":{"type":"string"},"nickname":{"type":"string"}},"required":["action"]}},"disambiguate":{"type":"object","properties":{"prompt":{"type":"string"},"candidates":{"type":"array","items":{"type":"object","properties":{"agent_id":{"type":"string"},"reason":{"type":"string"}},"required":["agent_id"]}}}}},"required":["reply","dispatch","ops"]}',
+  ],
+  output: "json",
+  input: "arg",
+  modelArg: "--model",
+  sessionArg: "--session-id",
+  systemPromptArg: "--append-system-prompt",
+};
+
+const DEFAULT_CODEX = {
+  command: "codex",
+  args: ["exec", "--json", "--color", "never", "--sandbox", "read-only", "--skip-git-repo-check"],
+  output: "jsonl",
+  input: "arg",
+  modelArg: "--model",
+  sessionArg: null,
+  fallbackArgs: ["exec", "--json", "--color", "never", "--sandbox", "read-only"],
+};
+
+function buildArgs(backend, prompt, opts) {
+  const args = [...(backend.args || [])];
+  if (opts.model && backend.modelArg) {
+    args.push(backend.modelArg, opts.model);
+  }
+  if (opts.sessionId && backend.sessionArg && !opts.disableSession) {
+    args.push(backend.sessionArg, opts.sessionId);
+  }
+  if (opts.systemPrompt && backend.systemPromptArg) {
+    args.push(backend.systemPromptArg, opts.systemPrompt);
+  }
+  if (backend.input === "arg") {
+    args.push(prompt);
+    return { args, stdin: "" };
+  }
+  return { args, stdin: prompt };
+}
+
+function isUnsupportedArgError(errText) {
+  const text = (errText || "").toLowerCase();
+  return text.includes("unknown option")
+    || text.includes("unknown argument")
+    || text.includes("unexpected argument")
+    || text.includes("unrecognized option");
+}
+
+async function runCliAgent(params) {
+  const backend = params.provider === "codex-cli" ? DEFAULT_CODEX : DEFAULT_CLAUDE;
+  const sessionId = params.sessionId || randomUUID();
+  const prompt =
+    params.systemPrompt && !backend.systemPromptArg
+      ? `${params.systemPrompt}\n\n${params.prompt}`
+      : params.prompt;
+  const { args, stdin } = buildArgs(backend, prompt, {
+    model: params.model,
+    sessionId,
+    systemPrompt: params.systemPrompt,
+    disableSession: params.disableSession,
+  });
+
+  let res;
+  const env = { ...process.env, ...(params.env || {}) };
+  delete env.CLAUDE_SESSION_ID;
+  delete env.CODEX_SESSION_ID;
+  try {
+    res = await runCommand(backend.command, args, {
+      cwd: params.cwd,
+      env,
+      input: stdin,
+      timeoutMs: params.timeoutMs || 300000,  // 5 minutes for complex tasks
+    });
+  } catch (err) {
+    return { ok: false, error: err.message || String(err), sessionId };
+  }
+
+  if (res.code !== 0) {
+    const err = res.stderr || res.stdout || "CLI failed";
+    if (backend === DEFAULT_CODEX && backend.fallbackArgs && isUnsupportedArgError(err)) {
+      const retry = buildArgs(
+        { ...backend, args: backend.fallbackArgs },
+        prompt,
+        {
+          model: params.model,
+          sessionId,
+          systemPrompt: params.systemPrompt,
+          disableSession: params.disableSession,
+        },
+      );
+      try {
+        res = await runCommand(backend.command, retry.args, {
+          cwd: params.cwd,
+          env,
+          input: retry.stdin,
+          timeoutMs: params.timeoutMs || 60000,
+        });
+      } catch (err2) {
+        return { ok: false, error: err2.message || String(err2), sessionId };
+      }
+      if (res.code !== 0) {
+        const err2 = res.stderr || res.stdout || "CLI failed";
+        return { ok: false, error: err2, sessionId };
+      }
+    } else {
+      return { ok: false, error: err, sessionId };
+    }
+  }
+
+  if (backend.output === "jsonl") {
+    return { ok: true, sessionId, output: collectJsonl(res.stdout) };
+  }
+
+  return { ok: true, sessionId, output: collectJson(res.stdout) };
+}
+
+module.exports = { runCliAgent };

package/src/agent/internalRunner.js

@@ -0,0 +1,212 @@
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { randomBytes } = require("crypto");
+const { runCliAgent } = require("./cliRunner");
+const { normalizeCliOutput } = require("./normalizeOutput");
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function generateSessionId() {
+  return randomBytes(4).toString("hex");
+}
+
+function buildEnv(agentType, sessionId, publisher, nickname) {
+  const env = { ...process.env };
+  if (agentType === "codex") {
+    env.CODEX_SESSION_ID = sessionId;
+    env.CLAUDE_SESSION_ID = "";
+  } else {
+    env.CLAUDE_SESSION_ID = sessionId;
+    env.CODEX_SESSION_ID = "";
+  }
+  env.AI_BUS_PUBLISHER = publisher || env.AI_BUS_PUBLISHER || "";
+  env.UFOO_NICKNAME = nickname || env.UFOO_NICKNAME || "";
+  env.UFOO_PARENT_PID = String(process.pid);
+  return env;
+}
+
+function joinBus(projectRoot, agentType, sessionId, nickname) {
+  const env = buildEnv(agentType, sessionId, "", nickname);
+  const args = ["bus", "join", sessionId, agentType === "codex" ? "codex" : "claude-code"];
+  if (nickname) args.push(nickname);
+  const res = spawnSync("ufoo", args, {
+    cwd: projectRoot,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (res.status !== 0) {
+    const err = (res.stderr || res.stdout || "").toString("utf8").trim();
+    throw new Error(err || "bus join failed");
+  }
+  const out = (res.stdout || "").toString("utf8").trim().split(/\r?\n/);
+  const subscriber = out[out.length - 1];
+  return { subscriber, env };
+}
+
+function safeSubscriber(subscriber) {
+  return subscriber.replace(/:/g, "_");
+}
+
+function readQueue(queueFile) {
+  if (!fs.existsSync(queueFile)) return [];
+  try {
+    const content = fs.readFileSync(queueFile, "utf8");
+    if (!content.trim()) return [];
+    return content.split(/\r?\n/).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function truncateQueue(queueFile) {
+  try {
+    fs.truncateSync(queueFile, 0);
+  } catch {
+    // ignore
+  }
+}
+
+async function handleEvent(projectRoot, agentType, provider, model, subscriber, sessionId, nickname, evt, cliSessionState) {
+  if (!evt || !evt.data || !evt.data.message) return;
+  const prompt = evt.data.message;
+  const publisher = evt.publisher || "unknown";
+
+  let res = await runCliAgent({
+    provider,
+    model,
+    prompt,
+    sessionId: cliSessionState.cliSessionId,
+    cwd: projectRoot,
+  });
+
+  // Handle session errors with immediate retry (only for claude)
+  if (!res.ok && provider === "claude-cli") {
+    const errMsg = (res.error || "").toLowerCase();
+    if (errMsg.includes("session") || errMsg.includes("already in use")) {
+      // Clear session and retry immediately with new session
+      cliSessionState.cliSessionId = null;
+      cliSessionState.needsSave = true;
+
+      res = await runCliAgent({
+        provider,
+        model,
+        prompt,
+        sessionId: null, // Let runCliAgent generate new session
+        cwd: projectRoot,
+      });
+    }
+  }
+
+  // Update CLI session ID for continuity (only for claude)
+  if (res.ok && res.sessionId && provider === "claude-cli") {
+    cliSessionState.cliSessionId = res.sessionId;
+    cliSessionState.needsSave = true;
+  }
+
+  let reply = "";
+  if (res.ok) {
+    reply = normalizeCliOutput(res.output) || "";
+  } else {
+    reply = `[internal:${agentType}] error: ${res.error || "unknown error"}`;
+  }
+
+  if (!reply) return;
+
+  spawnSync("ufoo", ["bus", "send", publisher, reply], {
+    cwd: projectRoot,
+    env: buildEnv(agentType, sessionId, subscriber, nickname),
+    stdio: "ignore",
+  });
+}
+
+async function runInternalRunner({ projectRoot, agentType = "codex" }) {
+  const sessionId = generateSessionId();
+  const nickname = process.env.UFOO_NICKNAME || "";
+  const { subscriber } = joinBus(projectRoot, agentType, sessionId, nickname);
+  if (!subscriber) {
+    throw new Error("Failed to join bus for internal runner");
+  }
+
+  const queueDir = path.join(projectRoot, ".ufoo", "bus", "queues", safeSubscriber(subscriber));
+  const queueFile = path.join(queueDir, "pending.jsonl");
+  const provider = agentType === "codex" ? "codex-cli" : "claude-cli";
+  const model = process.env.UFOO_AGENT_MODEL || "";
+
+  // Session state management for CLI continuity
+  // Use stable path based on nickname (if exists) or agent type, NOT subscriber ID
+  const stableKey = nickname || `${agentType}-default`;
+  const sessionDir = path.join(projectRoot, ".ufoo", "agent", "sessions");
+  fs.mkdirSync(sessionDir, { recursive: true });
+  const stateFile = path.join(sessionDir, `${stableKey}.json`);
+
+  let cliSessionId = null;
+  // Only load session for claude (codex doesn't support sessions)
+  if (provider === "claude-cli") {
+    try {
+      const state = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+      cliSessionId = state.cliSessionId;
+    } catch {
+      // No previous session
+    }
+  }
+
+  let running = true;
+  let processing = false;
+
+  const stop = () => {
+    running = false;
+  };
+
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+
+  const cliSessionState = { cliSessionId, needsSave: false };
+
+  while (running) {
+    if (!processing) {
+      processing = true;
+      try {
+        const lines = readQueue(queueFile);
+        if (lines.length > 0) {
+          const events = [];
+          for (const line of lines) {
+            try {
+              events.push(JSON.parse(line));
+            } catch {
+              // ignore malformed line
+            }
+          }
+          truncateQueue(queueFile);
+
+          for (const evt of events) {
+            // eslint-disable-next-line no-await-in-loop
+            await handleEvent(projectRoot, agentType, provider, model, subscriber, sessionId, nickname, evt, cliSessionState);
+          }
+
+          // Persist CLI session state after processing (only if changed and for claude)
+          if (cliSessionState.needsSave && provider === "claude-cli") {
+            try {
+              fs.writeFileSync(stateFile, JSON.stringify({
+                cliSessionId: cliSessionState.cliSessionId,
+                nickname: nickname || "",
+                updated_at: new Date().toISOString(),
+              }));
+              cliSessionState.needsSave = false;
+            } catch {
+              // ignore save errors
+            }
+          }
+        }
+      } finally {
+        processing = false;
+      }
+    }
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(1000);
+  }
+}
+
+module.exports = { runInternalRunner };

package/src/agent/normalizeOutput.js

@@ -0,0 +1,41 @@
+function extractTextFromObject(obj) {
+  if (!obj || typeof obj !== "object") return "";
+  if (obj.structured_output && typeof obj.structured_output === "object") {
+    return JSON.stringify(obj.structured_output);
+  }
+  const candidates = ["output", "text", "message", "content", "output_text", "result"];
+  for (const key of candidates) {
+    const val = obj[key];
+    if (typeof val === "string") return val;
+  }
+  return "";
+}
+
+function normalizeCliOutput(output) {
+  if (!output) return "";
+  if (typeof output === "string") return output;
+  if (Array.isArray(output)) {
+    const parts = [];
+    for (const item of output) {
+      if (typeof item === "string") {
+        parts.push(item);
+        continue;
+      }
+      if (item && typeof item === "object") {
+        if (item.item && typeof item.item === "object") {
+          if (item.item.type === "agent_message" && typeof item.item.text === "string") {
+            parts.push(item.item.text);
+            continue;
+          }
+        }
+        if (typeof item.text === "string") parts.push(item.text);
+        else if (typeof item.content === "string") parts.push(item.content);
+        else if (typeof item.output === "string") parts.push(item.output);
+      }
+    }
+    return parts.join("\n").trim();
+  }
+  return extractTextFromObject(output);
+}
+
+module.exports = { normalizeCliOutput };