u-foo 1.9.7 → 2.1.0

package/src/assistant/bridge.js

@@ -1,178 +0,0 @@
-const { spawn } = require("child_process");
-const path = require("path");
-const {
-  DEFAULT_ASSISTANT_TIMEOUT_MS,
-  DEFAULT_ASSISTANT_TIMEOUT_GRACE_MS,
-  normalizeAssistantTimeoutMs,
-} = require("./constants");
-
-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 = DEFAULT_ASSISTANT_TIMEOUT_MS,
-} = {}) {
-  return new Promise((resolve) => {
-    const startedAt = Date.now();
-    const effectiveTimeoutMs = normalizeAssistantTimeoutMs(timeoutMs, DEFAULT_ASSISTANT_TIMEOUT_MS);
-    const { command, args } = resolveAssistantCommand();
-    const payload = {
-      request_id: `assistant-${startedAt}`,
-      project_root: projectRoot,
-      provider,
-      fallback_provider: fallbackProvider,
-      model,
-      task,
-      kind,
-      context,
-      expect,
-      timeout_ms: effectiveTimeoutMs,
-    };
-
-    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 },
-      });
-    }, effectiveTimeoutMs + DEFAULT_ASSISTANT_TIMEOUT_GRACE_MS);
-
-    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/constants.js

@@ -1,15 +0,0 @@
-const DEFAULT_ASSISTANT_TIMEOUT_MS = 600000; // 10 minutes
-const DEFAULT_ASSISTANT_TIMEOUT_GRACE_MS = 5000;
-
-function normalizeAssistantTimeoutMs(value, fallback = DEFAULT_ASSISTANT_TIMEOUT_MS) {
-  const parsed = Number(value);
-  const base = Number.isFinite(parsed) ? parsed : fallback;
-  if (!Number.isFinite(base)) return DEFAULT_ASSISTANT_TIMEOUT_MS;
-  return Math.max(1000, Math.floor(base));
-}
-
-module.exports = {
-  DEFAULT_ASSISTANT_TIMEOUT_MS,
-  DEFAULT_ASSISTANT_TIMEOUT_GRACE_MS,
-  normalizeAssistantTimeoutMs,
-};

package/src/assistant/engine.js

@@ -1,252 +0,0 @@
-const { spawn } = require("child_process");
-const { loadConfig, normalizeAssistantEngine } = require("../config");
-const { DEFAULT_ASSISTANT_TIMEOUT_MS, normalizeAssistantTimeoutMs } = require("./constants");
-
-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 requested = normalizeAssistantEngine(requestedProvider);
-  const fallback = normalizeAssistantEngine(fallbackProvider) || "codex";
-
-  let selected = requested;
-  // Omitted/auto assistant providers inherit the active ufoo-agent provider.
-  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));
-  if (Number.isFinite(payload.timeout_ms)) {
-    args.push("--timeout-ms", String(normalizeAssistantTimeoutMs(payload.timeout_ms)));
-  }
-  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 = DEFAULT_ASSISTANT_TIMEOUT_MS,
-}) {
-  const startedAt = Date.now();
-  const effectiveTimeoutMs = normalizeAssistantTimeoutMs(timeoutMs, DEFAULT_ASSISTANT_TIMEOUT_MS);
-
-  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",
-      });
-    }, effectiveTimeoutMs);
-
-    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

@@ -1,58 +0,0 @@
-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 };