u-foo 1.0.3 → 1.1.9

package/src/assistant/agent.js

@@ -0,0 +1,260 @@
+const fs = require("fs");
+const path = require("path");
+const { runCliAgent } = require("../agent/cliRunner");
+const { normalizeCliOutput } = require("../agent/normalizeOutput");
+const { resolveAssistantEngine, runExternalAssistantEngine } = require("./engine");
+const { getUfooPaths } = require("../ufoo/paths");
+
+const ASSISTANT_JSON_SCHEMA = {
+  type: "object",
+  properties: {
+    ok: { type: "boolean" },
+    summary: { type: "string" },
+    artifacts: {
+      type: "array",
+      items: { type: "string" },
+    },
+    logs: {
+      type: "array",
+      items: { type: "string" },
+    },
+    error: { type: "string" },
+    metrics: {
+      type: "object",
+      additionalProperties: true,
+    },
+  },
+  required: ["ok", "summary"],
+};
+
+function parseTaskPayload(payload = {}) {
+  const projectRoot = typeof payload.project_root === "string" ? payload.project_root : process.cwd();
+  const provider = typeof payload.provider === "string" ? payload.provider : "";
+  const fallbackProvider = typeof payload.fallback_provider === "string" ? payload.fallback_provider : "";
+  const model = typeof payload.model === "string" ? payload.model : "";
+  const task = typeof payload.task === "string" ? payload.task.trim() : "";
+  const kind = typeof payload.kind === "string" && payload.kind ? payload.kind : "mixed";
+  const context = typeof payload.context === "string" ? payload.context : "";
+  const expectText = typeof payload.expect === "string" ? payload.expect : "";
+  const timeoutMs = Number.isFinite(payload.timeout_ms) ? payload.timeout_ms : 60000;
+
+  return {
+    projectRoot,
+    provider,
+    fallbackProvider,
+    model,
+    task,
+    kind,
+    context,
+    expect: expectText,
+    timeoutMs,
+  };
+}
+
+function normalizeAssistantPayload(parsed, fallbackError = "") {
+  if (!parsed || typeof parsed !== "object") {
+    const text = String(parsed || "").trim();
+    if (text) {
+      return {
+        ok: true,
+        summary: text,
+        artifacts: [],
+        logs: [],
+        error: "",
+        metrics: {},
+      };
+    }
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: fallbackError || "assistant returned invalid payload",
+      metrics: {},
+    };
+  }
+
+  return {
+    ok: parsed.ok !== false,
+    summary: typeof parsed.summary === "string" ? parsed.summary : "",
+    artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
+    logs: Array.isArray(parsed.logs) ? parsed.logs : [],
+    error: typeof parsed.error === "string" ? parsed.error : "",
+    metrics: parsed.metrics && typeof parsed.metrics === "object" ? parsed.metrics : {},
+  };
+}
+
+function buildAssistantSystemPrompt(taskInput) {
+  return [
+    "You are ufoo-assistant-agent, a private helper for ufoo-agent.",
+    "You are NOT exposed on the event bus.",
+    "Execute the requested task using local project context and shell/tool access as needed.",
+    "Return ONLY JSON that matches schema: {ok, summary, artifacts, logs, error, metrics}.",
+    "Rules:",
+    "- summary: concise factual result for ufoo-agent to consume.",
+    "- artifacts: key files/commands/findings (short strings).",
+    "- logs: optional concise trace points.",
+    "- error: non-empty only when ok=false.",
+    "- Do not include markdown or prose outside JSON.",
+    "",
+    "Task input:",
+    JSON.stringify(taskInput),
+  ].join("\n");
+}
+
+function getAssistantStatePaths(projectRoot) {
+  const dir = getUfooPaths(projectRoot).agentDir;
+  return {
+    sessionDir: path.join(dir, "sessions"),
+  };
+}
+
+function getAssistantSessionStateFile(projectRoot, engine = "assistant") {
+  const { sessionDir } = getAssistantStatePaths(projectRoot);
+  return path.join(sessionDir, `ufoo-assistant-${engine}.json`);
+}
+
+function loadAssistantState(projectRoot, engine = "assistant") {
+  const file = getAssistantSessionStateFile(projectRoot, engine);
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveAssistantState(projectRoot, engine = "assistant", state = {}) {
+  const { sessionDir } = getAssistantStatePaths(projectRoot);
+  fs.mkdirSync(sessionDir, { recursive: true });
+  const file = getAssistantSessionStateFile(projectRoot, engine);
+  fs.writeFileSync(file, JSON.stringify(state, null, 2));
+}
+
+function isSessionError(errorText = "") {
+  const text = String(errorText || "").toLowerCase();
+  return text.includes("session id")
+    || text.includes("session-id")
+    || text.includes("already in use");
+}
+
+async function runAssistantAgentTask(payload = {}) {
+  const taskInput = parseTaskPayload(payload);
+  const startedAt = Date.now();
+
+  if (!taskInput.task) {
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: "missing task",
+      metrics: { duration_ms: Date.now() - startedAt },
+    };
+  }
+
+  const systemPrompt = buildAssistantSystemPrompt(taskInput);
+  const engine = resolveAssistantEngine({
+    projectRoot: taskInput.projectRoot,
+    requestedProvider: taskInput.provider,
+    requestedModel: taskInput.model,
+    fallbackProvider: taskInput.fallbackProvider,
+  });
+  const assistantState = loadAssistantState(taskInput.projectRoot, engine.engine);
+
+  let cliRes = null;
+  if (engine.kind === "external") {
+    cliRes = await runExternalAssistantEngine({
+      engine,
+      timeoutMs: taskInput.timeoutMs,
+      payload: {
+        request_type: "assistant_task",
+        schema_version: 1,
+        engine: engine.engine,
+        project_root: taskInput.projectRoot,
+        task: taskInput.task,
+        kind: taskInput.kind,
+        context: taskInput.context,
+        expect: taskInput.expect,
+        model: engine.model || "",
+        session_id: assistantState && typeof assistantState.sessionId === "string" ? assistantState.sessionId : "",
+        timeout_ms: taskInput.timeoutMs,
+      },
+    });
+  } else {
+    const runCli = async (sessionId) => runCliAgent({
+      provider: engine.provider,
+      model: engine.model,
+      prompt: taskInput.task,
+      systemPrompt,
+      jsonSchema: ASSISTANT_JSON_SCHEMA,
+      disableSession: false,
+      sessionId,
+      cwd: taskInput.projectRoot,
+      timeoutMs: taskInput.timeoutMs,
+      sandbox: taskInput.kind === "explore" ? "read-only" : "workspace-write",
+    });
+
+    const preferredSession = assistantState && typeof assistantState.sessionId === "string"
+      ? assistantState.sessionId
+      : undefined;
+    cliRes = await runCli(preferredSession);
+    if (!cliRes.ok && preferredSession && isSessionError(cliRes.error)) {
+      cliRes = await runCli(undefined);
+    }
+  }
+
+  if (!cliRes || cliRes.ok === false) {
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: (cliRes && cliRes.error) || "assistant cli failed",
+      metrics: { duration_ms: Date.now() - startedAt },
+    };
+  }
+
+  let result;
+  if (engine.kind === "external") {
+    result = normalizeAssistantPayload(cliRes);
+  } else {
+    const normalized = normalizeCliOutput(cliRes.output);
+    let parsed;
+    try {
+      parsed = JSON.parse(normalized);
+    } catch {
+      parsed = normalized;
+    }
+    result = normalizeAssistantPayload(parsed);
+  }
+
+  result.metrics = {
+    ...result.metrics,
+    duration_ms: Date.now() - startedAt,
+  };
+  if (!result.ok && !result.error) {
+    result.error = "assistant task failed";
+  }
+
+  saveAssistantState(taskInput.projectRoot, engine.engine, {
+    engine: engine.engine,
+    provider: engine.provider || "",
+    model: engine.model || "",
+    sessionId: cliRes && typeof cliRes.sessionId === "string" ? cliRes.sessionId : "",
+    updated_at: new Date().toISOString(),
+  });
+
+  return result;
+}
+
+module.exports = {
+  runAssistantAgentTask,
+  parseTaskPayload,
+  normalizeAssistantPayload,
+  buildAssistantSystemPrompt,
+  getAssistantSessionStateFile,
+  loadAssistantState,
+  saveAssistantState,
+  isSessionError,
+  ASSISTANT_JSON_SCHEMA,
+};

package/src/assistant/bridge.js

@@ -0,0 +1,172 @@
+const { spawn } = require("child_process");
+const path = require("path");
+
+function resolveAssistantCommand() {
+  const raw = String(process.env.UFOO_ASSISTANT_CMD || "ufoo-assistant-agent").trim();
+  if (!raw || raw === "ufoo-assistant-agent") {
+    return {
+      command: process.execPath,
+      args: [path.resolve(__dirname, "../../bin/ufoo-assistant-agent.js")],
+    };
+  }
+  const parts = raw.split(/\s+/).filter(Boolean);
+  if (parts.length === 0) {
+    return {
+      command: process.execPath,
+      args: [path.resolve(__dirname, "../../bin/ufoo-assistant-agent.js")],
+    };
+  }
+  return { command: parts[0], args: parts.slice(1) };
+}
+
+function parseAssistantOutput(stdout) {
+  const text = String(stdout || "").trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    // Continue to line-based fallback.
+  }
+
+  const lines = text.split(/\r?\n/).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    try {
+      return JSON.parse(lines[i]);
+    } catch {
+      // ignore malformed line
+    }
+  }
+  return null;
+}
+
+function normalizeResponse(parsed, fallbackError = "") {
+  if (!parsed || typeof parsed !== "object") {
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: fallbackError || "assistant returned invalid JSON",
+      metrics: {},
+    };
+  }
+
+  return {
+    ok: parsed.ok !== false,
+    summary: typeof parsed.summary === "string" ? parsed.summary : "",
+    artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
+    logs: Array.isArray(parsed.logs) ? parsed.logs : [],
+    error: typeof parsed.error === "string" ? parsed.error : "",
+    metrics: parsed.metrics && typeof parsed.metrics === "object" ? parsed.metrics : {},
+  };
+}
+
+async function runAssistantTask({
+  projectRoot,
+  provider = "",
+  fallbackProvider = "",
+  model = "",
+  task = "",
+  kind = "mixed",
+  context = "",
+  expect = "",
+  timeoutMs = 60000,
+} = {}) {
+  return new Promise((resolve) => {
+    const startedAt = Date.now();
+    const { command, args } = resolveAssistantCommand();
+    const payload = {
+      request_id: `assistant-${startedAt}`,
+      project_root: projectRoot,
+      provider,
+      fallback_provider: fallbackProvider,
+      model,
+      task,
+      kind,
+      context,
+      expect,
+      timeout_ms: timeoutMs,
+    };
+
+    const child = spawn(command, args, {
+      cwd: projectRoot,
+      env: { ...process.env, UFOO_ASSISTANT_MODE: "private" },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        // ignore
+      }
+      finish({
+        ok: false,
+        summary: "",
+        artifacts: [],
+        logs: [],
+        error: "assistant timeout",
+        metrics: { duration_ms: Date.now() - startedAt },
+      });
+    }, timeoutMs);
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      finish({
+        ok: false,
+        summary: "",
+        artifacts: [],
+        logs: [],
+        error: err && err.message ? err.message : "assistant spawn failed",
+        metrics: { duration_ms: Date.now() - startedAt },
+      });
+    });
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const parsed = parseAssistantOutput(stdout);
+      const fallbackError = code === 0
+        ? ""
+        : (stderr || `assistant exited with code ${code}`);
+      const normalized = normalizeResponse(parsed, fallbackError);
+      normalized.metrics = {
+        ...normalized.metrics,
+        duration_ms: Date.now() - startedAt,
+      };
+      if (!normalized.ok && !normalized.error) {
+        normalized.error = fallbackError || "assistant failed";
+      }
+      finish(normalized);
+    });
+
+    try {
+      child.stdin.write(`${JSON.stringify(payload)}\n`);
+      child.stdin.end();
+    } catch {
+      // stdin may already be closed.
+    }
+  });
+}
+
+module.exports = {
+  runAssistantTask,
+  parseAssistantOutput,
+  normalizeResponse,
+  resolveAssistantCommand,
+};

package/src/assistant/engine.js

@@ -0,0 +1,252 @@
+const { spawn } = require("child_process");
+const { loadConfig, normalizeAssistantEngine } = require("../config");
+
+function splitCommand(raw, fallback = "ufoo-engine") {
+  const text = String(raw || "").trim();
+  if (!text) return { command: fallback, args: [] };
+  const parts = text.split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return { command: fallback, args: [] };
+  return { command: parts[0], args: parts.slice(1) };
+}
+
+function resolveAssistantEngine({
+  projectRoot,
+  requestedProvider = "",
+  requestedModel = "",
+  fallbackProvider = "",
+} = {}) {
+  const config = loadConfig(projectRoot);
+
+  const hasRequestedProvider = String(requestedProvider || "").trim().length > 0;
+  const requested = normalizeAssistantEngine(requestedProvider);
+  const configEngine = normalizeAssistantEngine(config.assistantEngine);
+  const fallback = normalizeAssistantEngine(fallbackProvider) || "codex";
+
+  let selected = requested;
+  if (selected === "auto") {
+    // Explicit assistant_call provider=auto should inherit current main agent provider.
+    selected = hasRequestedProvider ? fallback : configEngine;
+  }
+  if (selected === "auto") selected = fallback;
+  if (selected === "auto") selected = "codex";
+
+  const model =
+    String(requestedModel || "").trim()
+    || String(process.env.UFOO_ASSISTANT_MODEL || "").trim()
+    || String(config.assistantModel || "").trim()
+    || "";
+
+  if (selected === "claude") {
+    return {
+      engine: "claude",
+      kind: "cli",
+      provider: "claude-cli",
+      model,
+    };
+  }
+
+  if (selected === "ufoo") {
+    const { command, args } = splitCommand(
+      process.env.UFOO_ASSISTANT_UFOO_CMD || config.assistantUfooCmd,
+      "ufoo-engine"
+    );
+    return {
+      engine: "ufoo",
+      kind: "external",
+      command,
+      args,
+      model,
+    };
+  }
+
+  return {
+    engine: "codex",
+    kind: "cli",
+    provider: "codex-cli",
+    model,
+  };
+}
+
+function parseEngineJson(stdout) {
+  const text = String(stdout || "").trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    // continue to line fallback
+  }
+  const lines = text.split(/\r?\n/).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    try {
+      return JSON.parse(lines[i]);
+    } catch {
+      // ignore bad lines
+    }
+  }
+  return null;
+}
+
+function isUnsupportedArgError(errText) {
+  const text = String(errText || "").toLowerCase();
+  return text.includes("unknown option")
+    || text.includes("unknown argument")
+    || text.includes("unexpected argument")
+    || text.includes("unrecognized option");
+}
+
+function buildExternalEngineArgs(engine = {}, payload = {}) {
+  const args = Array.isArray(engine.args) ? [...engine.args] : [];
+  args.push("--assistant-task", "--json");
+  if (payload.model) args.push("--model", String(payload.model));
+  if (payload.session_id) args.push("--session-id", String(payload.session_id));
+  if (payload.project_root) args.push("--cwd", String(payload.project_root));
+  if (payload.kind) args.push("--kind", String(payload.kind));
+  if (payload.context) args.push("--context", String(payload.context));
+  if (payload.expect) args.push("--expect", String(payload.expect));
+  args.push(String(payload.task || ""));
+  return args;
+}
+
+function extractSessionId(parsed) {
+  if (!parsed || typeof parsed !== "object") return "";
+  return String(parsed.session_id || parsed.sessionId || parsed.session || "").trim();
+}
+
+async function runExternalAssistantEngine({
+  engine,
+  payload,
+  timeoutMs = 60000,
+}) {
+  const startedAt = Date.now();
+
+  const runAttempt = (attempt = {}) => new Promise((resolve) => {
+    const child = spawn(engine.command, attempt.args || [], {
+      cwd: payload.project_root || process.cwd(),
+      env: { ...process.env, UFOO_ASSISTANT_ENGINE: engine.engine || "ufoo" },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        // ignore
+      }
+      finish({
+        ok: false,
+        mode: attempt.mode,
+        code: -1,
+        stdout,
+        stderr,
+        error: "assistant engine timeout",
+      });
+    }, timeoutMs);
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      finish({
+        ok: false,
+        mode: attempt.mode,
+        code: -1,
+        stdout,
+        stderr,
+        error: err && err.message ? err.message : "assistant engine spawn failed",
+      });
+    });
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      finish({
+        ok: code === 0,
+        mode: attempt.mode,
+        code,
+        stdout,
+        stderr,
+        error: "",
+      });
+    });
+
+    try {
+      if (attempt.input) child.stdin.write(attempt.input);
+      child.stdin.end();
+    } catch {
+      // ignore stdin errors
+    }
+  });
+
+  const argsAttempt = {
+    mode: "args",
+    args: buildExternalEngineArgs(engine, payload),
+    input: "",
+  };
+  let result = await runAttempt(argsAttempt);
+
+  if (!result.ok && isUnsupportedArgError(result.stderr || result.stdout || result.error)) {
+    result = await runAttempt({
+      mode: "stdin-json",
+      args: Array.isArray(engine.args) ? [...engine.args] : [],
+      input: `${JSON.stringify(payload)}\n`,
+    });
+  }
+
+  const parsed = parseEngineJson(result.stdout);
+  if (parsed && typeof parsed === "object") {
+    return {
+      ...parsed,
+      sessionId: extractSessionId(parsed),
+      metrics: {
+        ...(parsed.metrics && typeof parsed.metrics === "object" ? parsed.metrics : {}),
+        duration_ms: Date.now() - startedAt,
+      },
+    };
+  }
+
+  if (result.ok) {
+    const summary = String(result.stdout || "").trim();
+    return {
+      ok: true,
+      summary,
+      artifacts: [],
+      logs: [],
+      error: "",
+      sessionId: "",
+      metrics: { duration_ms: Date.now() - startedAt },
+    };
+  }
+
+  return {
+    ok: false,
+    summary: "",
+    artifacts: [],
+    logs: [],
+    error: String(result.stderr || result.stdout || result.error || `assistant engine exited with code ${result.code}`).trim(),
+    sessionId: "",
+    metrics: { duration_ms: Date.now() - startedAt },
+  };
+}
+
+module.exports = {
+  resolveAssistantEngine,
+  runExternalAssistantEngine,
+  parseEngineJson,
+  splitCommand,
+  buildExternalEngineArgs,
+  isUnsupportedArgError,
+  extractSessionId,
+};