@poncho-ai/cli 0.3.0 → 0.3.2

package/dist/cli.js

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "./chunk-HDKWXGXT.js";
-import "./chunk-3BEWSRFW.js";
+} from "./chunk-ESPC4MPN.js";
 
 // src/cli.ts
 void main();

package/dist/index.d.ts

@@ -6,6 +6,11 @@ type InitOnboardingOptions = {
     interactive?: boolean;
 };
 
+/**
+ * Detects the runtime environment from platform-specific or standard environment variables.
+ * Priority: PONCHO_ENV > platform detection (Vercel, Railway, etc.) > NODE_ENV > "development"
+ */
+declare const resolveHarnessEnvironment: () => "development" | "staging" | "production";
 declare const initProject: (projectName: string, options?: {
     workingDir?: string;
     onboarding?: InitOnboardingOptions;
@@ -50,4 +55,4 @@ declare const buildCli: () => Command;
 declare const main: (argv?: string[]) => Promise<void>;
 declare const packageRoot: string;
 
-export { type RequestHandler, addSkill, buildCli, buildTarget, createRequestHandler, initProject, listTools, main, mcpAdd, mcpList, mcpRemove, mcpToolsList, mcpToolsSelect, packageRoot, runInteractive, runOnce, runTests, startDevServer, updateAgentGuidance };
+export { type RequestHandler, addSkill, buildCli, buildTarget, createRequestHandler, initProject, listTools, main, mcpAdd, mcpList, mcpRemove, mcpToolsList, mcpToolsSelect, packageRoot, resolveHarnessEnvironment, runInteractive, runOnce, runTests, startDevServer, updateAgentGuidance };

package/dist/index.js

@@ -12,13 +12,13 @@ import {
   mcpToolsList,
   mcpToolsSelect,
   packageRoot,
+  resolveHarnessEnvironment,
   runInteractive,
   runOnce,
   runTests,
   startDevServer,
   updateAgentGuidance
-} from "./chunk-HDKWXGXT.js";
-import "./chunk-3BEWSRFW.js";
+} from "./chunk-ESPC4MPN.js";
 export {
   addSkill,
   buildCli,
@@ -33,6 +33,7 @@ export {
   mcpToolsList,
   mcpToolsSelect,
   packageRoot,
+  resolveHarnessEnvironment,
   runInteractive,
   runOnce,
   runTests,

package/dist/run-interactive-ink-BOD2F5JM.js

@@ -0,0 +1,463 @@
+import {
+  consumeFirstRunIntro,
+  inferConversationTitle,
+  resolveHarnessEnvironment
+} from "./chunk-ESPC4MPN.js";
+
+// src/run-interactive-ink.ts
+import * as readline from "readline";
+import { stdout } from "process";
+import {
+  parseAgentFile
+} from "@poncho-ai/harness";
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m",
+  magenta: "\x1B[35m"
+};
+var green = (s) => `${C.green}${s}${C.reset}`;
+var yellow = (s) => `${C.yellow}${s}${C.reset}`;
+var red = (s) => `${C.red}${s}${C.reset}`;
+var gray = (s) => `${C.gray}${s}${C.reset}`;
+var magenta = (s) => `${C.magenta}${s}${C.reset}`;
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var formatDuration = (ms) => ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+var stringifyValue = (v) => {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+};
+var truncate = (v, max) => v.length <= max ? v : `${v.slice(0, Math.max(0, max - 3))}...`;
+var compactPreview = (v, max = 120) => truncate(stringifyValue(v).replace(/\s+/g, " "), max);
+var loadMetadata = async (workingDir) => {
+  let agentName = "agent";
+  let model = "unknown";
+  let provider = "unknown";
+  try {
+    const parsed = await parseAgentFile(workingDir);
+    agentName = parsed.frontmatter.name ?? agentName;
+    model = parsed.frontmatter.model?.name ?? model;
+    provider = parsed.frontmatter.model?.provider ?? provider;
+  } catch {
+  }
+  return {
+    agentName,
+    model,
+    provider,
+    workingDir,
+    environment: resolveHarnessEnvironment()
+  };
+};
+var ask = (rl, prompt) => new Promise((res) => {
+  rl.question(prompt, (answer) => res(answer));
+});
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var streamTextAsTokens = async (text) => {
+  const tokens = text.match(/\S+\s*|\n/g) ?? [text];
+  for (const token of tokens) {
+    stdout.write(token);
+    const trimmed = token.trim();
+    const delay = trimmed.length === 0 ? 0 : Math.max(4, Math.min(18, Math.floor(trimmed.length / 2)));
+    await sleep(delay);
+  }
+};
+var OWNER_ID = "local-owner";
+var computeTurn = (messages) => Math.max(1, Math.floor(messages.length / 2) + 1);
+var formatDate = (value) => {
+  try {
+    return new Date(value).toLocaleString();
+  } catch {
+    return String(value);
+  }
+};
+var handleSlash = async (command, state, conversationStore) => {
+  const [rawCommand, ...args] = command.trim().split(/\s+/);
+  const norm = rawCommand.toLowerCase();
+  if (norm === "/help") {
+    console.log(
+      gray(
+        "commands> /help /clear /exit /tools /list /open <id> /new [title] /delete [id] /continue /reset [all]"
+      )
+    );
+    return { shouldExit: false };
+  }
+  if (norm === "/clear") {
+    process.stdout.write("\x1B[2J\x1B[H");
+    return { shouldExit: false };
+  }
+  if (norm === "/exit") {
+    return { shouldExit: true };
+  }
+  if (norm === "/list") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    if (conversations.length === 0) {
+      console.log(gray("conversations> none"));
+      return { shouldExit: false };
+    }
+    console.log(gray("conversations>"));
+    for (const conversation of conversations) {
+      const activeMarker = state.activeConversationId === conversation.conversationId ? "*" : " ";
+      console.log(
+        gray(
+          `${activeMarker} ${conversation.conversationId} | ${conversation.title} | ${formatDate(conversation.updatedAt)}`
+        )
+      );
+    }
+    return { shouldExit: false };
+  }
+  if (norm === "/open") {
+    const conversationId = args[0];
+    if (!conversationId) {
+      console.log(yellow("usage> /open <conversationId>"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(conversationId);
+    if (!conversation) {
+      console.log(yellow(`conversations> not found: ${conversationId}`));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [...conversation.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> opened ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/new") {
+    const title = args.join(" ").trim();
+    const conversation = await conversationStore.create(OWNER_ID, title || void 0);
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> new ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/delete") {
+    const targetConversationId = args[0] ?? state.activeConversationId ?? "";
+    if (!targetConversationId) {
+      console.log(yellow("usage> /delete <conversationId>"));
+      return { shouldExit: false };
+    }
+    const removed = await conversationStore.delete(targetConversationId);
+    if (!removed) {
+      console.log(yellow(`conversations> not found: ${targetConversationId}`));
+      return { shouldExit: false };
+    }
+    if (state.activeConversationId === targetConversationId) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+    }
+    console.log(gray(`conversations> deleted ${targetConversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/continue") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    const latest = conversations[0];
+    if (!latest) {
+      console.log(yellow("conversations> no conversations to continue"));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = latest.conversationId;
+    state.messages = [...latest.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> continued ${latest.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/reset") {
+    if (args[0]?.toLowerCase() === "all") {
+      const conversations = await conversationStore.list(OWNER_ID);
+      for (const conversation2 of conversations) {
+        await conversationStore.delete(conversation2.conversationId);
+      }
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> reset all"));
+      return { shouldExit: false };
+    }
+    if (!state.activeConversationId) {
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> current session reset"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(state.activeConversationId);
+    if (!conversation) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(yellow("conversations> active conversation no longer exists"));
+      return { shouldExit: false };
+    }
+    await conversationStore.update({
+      ...conversation,
+      messages: []
+    });
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> reset ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  console.log(yellow(`Unknown command: ${command}`));
+  return { shouldExit: false };
+};
+var runInteractiveInk = async ({
+  harness,
+  params,
+  workingDir,
+  config,
+  conversationStore,
+  onSetApprovalCallback
+}) => {
+  const metadata = await loadMetadata(workingDir);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  if (onSetApprovalCallback) {
+    onSetApprovalCallback((req) => {
+      process.stdout.write("\n");
+      const preview = compactPreview(req.input, 100);
+      rl.question(
+        `${C.yellow}${C.bold}Tool "${req.tool}" requires approval${C.reset}
+${C.gray}input: ${preview}${C.reset}
+${C.yellow}approve? (y/n): ${C.reset}`,
+        (answer) => {
+          const approved = answer.trim().toLowerCase() === "y";
+          console.log(
+            approved ? green(`  approved ${req.tool}`) : magenta(`  denied ${req.tool}`)
+          );
+          req.resolve(approved);
+        }
+      );
+    });
+  }
+  console.log(
+    gray(
+      `
+${metadata.agentName} | ${metadata.provider}/${metadata.model} | ${metadata.environment}`
+    )
+  );
+  console.log(gray('Type "exit" to quit, "/help" for commands'));
+  console.log(
+    gray("Conversation controls: /list /open <id> /new [title] /delete [id] /continue /reset [all]\n")
+  );
+  const intro = await consumeFirstRunIntro(workingDir, {
+    agentName: metadata.agentName,
+    provider: metadata.provider,
+    model: metadata.model,
+    config
+  });
+  if (intro) {
+    console.log(green("assistant>"));
+    await streamTextAsTokens(intro);
+    stdout.write("\n\n");
+  }
+  let messages = intro ? [{ role: "assistant", content: intro }] : [];
+  let turn = 1;
+  let activeConversationId = null;
+  let showToolPayloads = false;
+  const prompt = `${C.cyan}you> ${C.reset}`;
+  while (true) {
+    let task;
+    try {
+      task = await ask(rl, prompt);
+    } catch {
+      break;
+    }
+    const trimmed = task.trim();
+    if (!trimmed) continue;
+    if (trimmed.toLowerCase() === "exit") break;
+    if (trimmed.startsWith("/")) {
+      if (trimmed.toLowerCase() === "/exit") break;
+      if (trimmed.toLowerCase() === "/tools") {
+        showToolPayloads = !showToolPayloads;
+        console.log(gray(`tool payloads: ${showToolPayloads ? "on" : "off"}`));
+        continue;
+      }
+      const interactiveState = {
+        messages,
+        turn,
+        activeConversationId
+      };
+      const slashResult = await handleSlash(
+        trimmed,
+        interactiveState,
+        conversationStore
+      );
+      if (slashResult.shouldExit) {
+        break;
+      }
+      messages = interactiveState.messages;
+      turn = interactiveState.turn;
+      activeConversationId = interactiveState.activeConversationId;
+      continue;
+    }
+    console.log(gray(`
+--- turn ${turn} ---`));
+    process.stdout.write(gray("thinking..."));
+    let thinkingCleared = false;
+    const clearThinking = () => {
+      if (thinkingCleared) return;
+      thinkingCleared = true;
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+    };
+    let responseText = "";
+    let streamedText = "";
+    let committedText = false;
+    let sawChunk = false;
+    let toolEvents = 0;
+    const toolTimeline = [];
+    let runFailed = false;
+    let usage;
+    let latestRunId = "";
+    const startedAt = Date.now();
+    try {
+      for await (const event of harness.run({
+        task: trimmed,
+        parameters: params,
+        messages
+      })) {
+        if (event.type === "run:started") {
+          latestRunId = event.runId;
+        }
+        if (event.type === "model:chunk") {
+          sawChunk = true;
+          responseText += event.content;
+          streamedText += event.content;
+          if (!thinkingCleared) {
+            clearThinking();
+            process.stdout.write(`${C.green}assistant> ${C.reset}`);
+          }
+          process.stdout.write(event.content);
+        } else if (event.type === "tool:started" || event.type === "tool:completed" || event.type === "tool:error" || event.type === "tool:approval:required" || event.type === "tool:approval:granted" || event.type === "tool:approval:denied") {
+          if (streamedText.length > 0) {
+            committedText = true;
+            streamedText = "";
+            process.stdout.write("\n");
+          }
+          clearThinking();
+          if (event.type === "tool:started") {
+            const preview = showToolPayloads ? compactPreview(event.input, 400) : compactPreview(event.input, 100);
+            console.log(yellow(`tools> start ${event.tool} input=${preview}`));
+            toolTimeline.push(`- start \`${event.tool}\``);
+            toolEvents += 1;
+          } else if (event.type === "tool:completed") {
+            const preview = showToolPayloads ? compactPreview(event.output, 400) : compactPreview(event.output, 100);
+            console.log(
+              yellow(
+                `tools> done  ${event.tool} in ${formatDuration(event.duration)}`
+              )
+            );
+            if (showToolPayloads) {
+              console.log(yellow(`tools> output ${preview}`));
+            }
+            toolTimeline.push(
+              `- done \`${event.tool}\` in ${formatDuration(event.duration)}`
+            );
+          } else if (event.type === "tool:error") {
+            console.log(
+              red(`tools> error ${event.tool}: ${event.error}`)
+            );
+            toolTimeline.push(`- error \`${event.tool}\`: ${event.error}`);
+          } else if (event.type === "tool:approval:required") {
+            console.log(
+              magenta(`tools> approval required for ${event.tool}`)
+            );
+            toolTimeline.push(`- approval required \`${event.tool}\``);
+          } else if (event.type === "tool:approval:granted") {
+            console.log(
+              gray(`tools> approval granted (${event.approvalId})`)
+            );
+            toolTimeline.push(`- approval granted (${event.approvalId})`);
+          } else if (event.type === "tool:approval:denied") {
+            console.log(
+              magenta(`tools> approval denied (${event.approvalId})`)
+            );
+            toolTimeline.push(`- approval denied (${event.approvalId})`);
+          }
+        } else if (event.type === "run:error") {
+          clearThinking();
+          runFailed = true;
+          console.log(red(`error> ${event.error.message}`));
+        } else if (event.type === "model:response") {
+          usage = event.usage;
+        } else if (event.type === "run:completed" && !sawChunk) {
+          clearThinking();
+          responseText = event.result.response ?? "";
+          if (responseText.length > 0) {
+            process.stdout.write(
+              `${C.green}assistant> ${C.reset}${responseText}
+`
+            );
+          }
+        }
+      }
+    } catch (error) {
+      clearThinking();
+      runFailed = true;
+      console.log(
+        red(
+          `error> ${error instanceof Error ? error.message : "Unknown error"}`
+        )
+      );
+    }
+    if (sawChunk && streamedText.length > 0) {
+      process.stdout.write("\n");
+    } else if (!sawChunk && !runFailed && responseText.length === 0) {
+      clearThinking();
+      console.log(green("assistant> (no response)"));
+    }
+    const fullResponse = responseText || streamedText;
+    if (!runFailed && toolEvents === 0 && FAUX_TOOL_LOG_PATTERN.test(fullResponse)) {
+      console.log(
+        magenta(
+          "warning> assistant described tool execution but no real tool events occurred."
+        )
+      );
+    }
+    const durationMs = Date.now() - startedAt;
+    console.log(
+      gray(`meta> ${formatDuration(durationMs)} | tools: ${toolEvents}
+`)
+    );
+    if (!activeConversationId) {
+      const created = await conversationStore.create(
+        OWNER_ID,
+        inferConversationTitle(trimmed)
+      );
+      activeConversationId = created.conversationId;
+    }
+    messages.push({ role: "user", content: trimmed });
+    messages.push({
+      role: "assistant",
+      content: responseText,
+      metadata: toolTimeline.length > 0 ? { toolActivity: toolTimeline } : void 0
+    });
+    turn = computeTurn(messages);
+    const conversation = await conversationStore.get(activeConversationId);
+    if (conversation) {
+      const maybeTitle = conversation.messages.length === 0 && (conversation.title === "New conversation" || conversation.title.trim().length === 0) ? inferConversationTitle(trimmed) : conversation.title;
+      await conversationStore.update({
+        ...conversation,
+        title: maybeTitle,
+        messages: [...messages],
+        runtimeRunId: latestRunId || conversation.runtimeRunId
+      });
+    }
+  }
+  rl.close();
+};
+export {
+  runInteractiveInk
+};