u-foo 1.0.6 → 1.1.9

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,
+};

package/src/assistant/stdio.js

@@ -0,0 +1,58 @@
+const { runAssistantAgentTask } = require("./agent");
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.resume();
+  });
+}
+
+async function runAssistantStdio() {
+  const startedAt = Date.now();
+  try {
+    const input = await readStdin();
+    const line = String(input || "")
+      .split(/\r?\n/)
+      .map((part) => part.trim())
+      .find(Boolean);
+
+    if (!line) {
+      process.stdout.write(
+        `${JSON.stringify({
+          ok: false,
+          summary: "",
+          artifacts: [],
+          logs: [],
+          error: "missing request payload",
+          metrics: { duration_ms: Date.now() - startedAt },
+        })}\n`
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    const payload = JSON.parse(line);
+    const result = await runAssistantAgentTask(payload);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.ok ? 0 : 1;
+  } catch (err) {
+    process.stdout.write(
+      `${JSON.stringify({
+        ok: false,
+        summary: "",
+        artifacts: [],
+        logs: [],
+        error: err && err.message ? err.message : "assistant stdio failed",
+        metrics: { duration_ms: Date.now() - startedAt },
+      })}\n`
+    );
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { runAssistantStdio };