@agentic-patterns/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1266 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "util";
+
+// src/commands/agents.ts
+import path from "path";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var YELLOW = "\x1B[33m";
+function runAgentsCommand(input) {
+  const { agents, loadErrors, root } = input;
+  process.stdout.write("\n");
+  if (agents.length === 0) {
+    process.stdout.write(
+      `  ${DIM}no agents discovered. Drop a file at ./agents/<name>/agent.ts that default-exports { id, name, agent }.${RESET}
+
+`
+    );
+  } else {
+    process.stdout.write(
+      `  ${BOLD}${agents.length} agent${agents.length === 1 ? "" : "s"}${RESET}
+
+`
+    );
+    const idCol = Math.max(...agents.map((a) => a.id.length), 8);
+    for (const a of agents) {
+      const rel = path.relative(root, a.file);
+      process.stdout.write(`  ${a.id.padEnd(idCol)}  ${a.name}  ${DIM}${rel}${RESET}
+`);
+      if (a.description) {
+        process.stdout.write(`  ${"".padEnd(idCol)}  ${DIM}${a.description}${RESET}
+`);
+      }
+    }
+    process.stdout.write("\n");
+  }
+  if (loadErrors.length > 0) {
+    process.stdout.write(`  ${YELLOW}${loadErrors.length} load error(s):${RESET}
+`);
+    for (const err of loadErrors) {
+      process.stdout.write(`    ${YELLOW}!${RESET} ${err.file}: ${err.error.message}
+`);
+    }
+    process.stdout.write("\n");
+  }
+}
+
+// src/commands/config.ts
+import fs from "fs";
+import path2 from "path";
+import { isCancel, password, select, text } from "@clack/prompts";
+var BOLD2 = "\x1B[1m";
+var DIM2 = "\x1B[2m";
+var RESET2 = "\x1B[0m";
+var GREEN = "\x1B[32m";
+var TRACKED_ENV = [
+  { key: "ANTHROPIC_API_KEY", label: "Anthropic API key", secret: true },
+  { key: "OPENAI_API_KEY", label: "OpenAI API key", secret: true },
+  { key: "GOOGLE_GENERATIVE_AI_API_KEY", label: "Google API key", secret: true },
+  { key: "GROQ_API_KEY", label: "Groq API key", secret: true },
+  { key: "MISTRAL_API_KEY", label: "Mistral API key", secret: true },
+  { key: "XAI_API_KEY", label: "xAI API key", secret: true },
+  { key: "DEEPSEEK_API_KEY", label: "DeepSeek API key", secret: true },
+  { key: "OPENROUTER_API_KEY", label: "OpenRouter API key", secret: true },
+  { key: "OLLAMA_HOST", label: "Ollama host URL", secret: false },
+  { key: "AGENT_TIER", label: "Default tier (opus | sonnet | haiku)", secret: false }
+];
+function runConfigStatusCommand(input) {
+  const { config } = input;
+  const envFile = path2.join(config.root, ".env");
+  const envExists = fs.existsSync(envFile);
+  process.stdout.write("\n");
+  process.stdout.write(`  ${BOLD2}config${RESET2}
+
+`);
+  process.stdout.write(
+    `  .env       ${envExists ? `${GREEN}loaded${RESET2} ${DIM2}from ${path2.relative(process.cwd(), envFile)}${RESET2}` : `${DIM2}not present${RESET2}`}
+`
+  );
+  const longestKey = Math.max(...TRACKED_ENV.map((e) => e.key.length));
+  for (const spec of TRACKED_ENV) {
+    const value = process.env[spec.key];
+    const padded = spec.key.padEnd(longestKey);
+    if (value) {
+      const display = spec.secret ? maskSecret(value) : value;
+      process.stdout.write(`  ${padded}  ${GREEN}\u2713${RESET2}  ${DIM2}${display}${RESET2}
+`);
+    } else {
+      process.stdout.write(`  ${padded}  ${DIM2}\u2014  not set${RESET2}
+`);
+    }
+  }
+  process.stdout.write("\n");
+  process.stdout.write(`  ${DIM2}ap config set to edit interactively${RESET2}
+
+`);
+}
+async function runConfigSetCommand(input) {
+  const { config } = input;
+  const envFile = path2.join(config.root, ".env");
+  const choice = await select({
+    message: "Which env var?",
+    options: TRACKED_ENV.map((spec2) => {
+      const current = process.env[spec2.key];
+      const hint = current ? spec2.secret ? maskSecret(current) : current : "not set";
+      return {
+        value: spec2.key,
+        label: spec2.key,
+        hint
+      };
+    })
+  });
+  if (isCancel(choice)) {
+    process.stdout.write(`
+${DIM2}cancelled${RESET2}
+`);
+    return;
+  }
+  const spec = TRACKED_ENV.find((e) => e.key === choice);
+  if (!spec) return;
+  const prompt = spec.secret ? password : text;
+  const value = await prompt({
+    message: `${spec.label} (${spec.key}):`,
+    placeholder: process.env[spec.key] ?? ""
+  });
+  if (isCancel(value)) {
+    process.stdout.write(`
+${DIM2}cancelled${RESET2}
+`);
+    return;
+  }
+  upsertEnvFile(envFile, spec.key, String(value));
+  process.stdout.write(
+    `
+  ${GREEN}\u2713${RESET2} wrote ${BOLD2}${spec.key}${RESET2} to ${path2.relative(process.cwd(), envFile)}
+
+`
+  );
+}
+function maskSecret(v) {
+  if (v.length <= 8) return "\u2022".repeat(v.length);
+  return `${v.slice(0, 4)}${"\u2022".repeat(Math.min(8, v.length - 8))}${v.slice(-4)}`;
+}
+function upsertEnvFile(file, key, value) {
+  let lines = [];
+  if (fs.existsSync(file)) {
+    lines = fs.readFileSync(file, "utf-8").split("\n");
+  }
+  const prefix = `${key}=`;
+  const idx = lines.findIndex((l) => l.trim().startsWith(prefix));
+  const formatted = `${key}=${value}`;
+  if (idx === -1) {
+    if (lines.length > 0 && lines[lines.length - 1] !== "") lines.push("");
+    lines.push(formatted);
+  } else {
+    lines[idx] = formatted;
+  }
+  fs.writeFileSync(
+    file,
+    `${lines.filter((l, i, arr) => !(l === "" && i === arr.length - 1)).join("\n")}
+`
+  );
+  if (!process.env[key] || process.env[key] !== value) {
+    process.env[key] = value;
+  }
+}
+
+// src/commands/init.ts
+import fs2 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { isCancel as isCancel2, select as select2, text as text2 } from "@clack/prompts";
+var DIM3 = "\x1B[2m";
+var BOLD3 = "\x1B[1m";
+var GREEN2 = "\x1B[32m";
+var YELLOW2 = "\x1B[33m";
+var RESET3 = "\x1B[0m";
+var VALID_PROVIDERS = ["anthropic", "openai", "ollama"];
+async function runInitCommand(opts) {
+  let targetDir;
+  let projectName;
+  let monorepoRoot = null;
+  if (opts.link) {
+    monorepoRoot = resolveMonorepoRoot();
+    if (!monorepoRoot) {
+      process.stderr.write(
+        `error: --link requires the CLI to be run from the agentic-patterns-ts source tree
+`
+      );
+      process.exit(1);
+    }
+    const name = opts.targetDir ?? await promptName();
+    if (name === null) {
+      process.stdout.write(`${DIM3}cancelled.${RESET3}
+`);
+      return;
+    }
+    projectName = name;
+    targetDir = path3.join(monorepoRoot, "examples", projectName);
+  } else if (opts.targetDir === void 0) {
+    const name = await promptName();
+    if (name === null) {
+      process.stdout.write(`${DIM3}cancelled.${RESET3}
+`);
+      return;
+    }
+    projectName = name;
+    targetDir = path3.resolve(process.cwd(), projectName);
+  } else if (opts.targetDir === ".") {
+    targetDir = process.cwd();
+    projectName = path3.basename(targetDir);
+  } else {
+    targetDir = path3.resolve(process.cwd(), opts.targetDir);
+    projectName = path3.basename(targetDir);
+  }
+  let provider;
+  if (opts.provider !== void 0) {
+    if (!VALID_PROVIDERS.includes(opts.provider)) {
+      process.stderr.write(
+        `error: invalid --provider "${opts.provider}" (expected anthropic | openai | ollama)
+`
+      );
+      process.exit(1);
+    }
+    provider = opts.provider;
+  } else {
+    const answer = await select2({
+      message: "provider",
+      options: [
+        { value: "anthropic", label: "Anthropic (Claude)" },
+        { value: "openai", label: "OpenAI (GPT)" },
+        { value: "ollama", label: "Ollama (local)" }
+      ],
+      initialValue: "anthropic"
+    });
+    if (isCancel2(answer)) {
+      process.stdout.write(`${DIM3}cancelled.${RESET3}
+`);
+      return;
+    }
+    provider = answer;
+  }
+  if (fs2.existsSync(targetDir)) {
+    const stat = fs2.statSync(targetDir);
+    if (!stat.isDirectory()) {
+      process.stderr.write(`error: target ${targetDir} exists and is not a directory
+`);
+      process.exit(1);
+    }
+    const conflicts = ["package.json", "agents", "tsconfig.json"].filter(
+      (n) => fs2.existsSync(path3.join(targetDir, n))
+    );
+    if (conflicts.length > 0) {
+      process.stderr.write(
+        `error: target ${targetDir} already contains: ${conflicts.join(", ")}
+`
+      );
+      process.exit(1);
+    }
+  } else {
+    fs2.mkdirSync(targetDir, { recursive: true });
+  }
+  const created = [];
+  writeFile(
+    targetDir,
+    "package.json",
+    renderPackageJson(projectName, provider, opts.link === true),
+    created
+  );
+  writeFile(targetDir, ".env.example", renderEnvExample(provider), created);
+  writeFile(targetDir, "tsconfig.json", renderTsConfig(), created);
+  writeFile(targetDir, path3.join("agents", "demo", "agent.ts"), renderAgent(provider), created);
+  let pluginNote = null;
+  if (opts.withPlugin) {
+    const pluginSrc = resolvePluginSource();
+    if (pluginSrc) {
+      copyDir(pluginSrc.pluginDir, path3.join(targetDir, ".claude-plugin"));
+      copyDir(pluginSrc.hooksDir, path3.join(targetDir, "hooks"));
+      created.push(".claude-plugin/", "hooks/");
+    } else {
+      pluginNote = `${YELLOW2}warning${RESET3}: --with-plugin requested but plugin source not found.
+   ${DIM3}Run from the agentic-patterns-ts source tree, or wait for plugin packaging (Phase 2).${RESET3}`;
+    }
+  }
+  const rel = path3.relative(process.cwd(), targetDir) || ".";
+  process.stdout.write(`
+  ${GREEN2}created${RESET3} ${BOLD3}${rel}${RESET3}
+
+`);
+  for (const f of created) {
+    process.stdout.write(`    ${DIM3}+ ${f}${RESET3}
+`);
+  }
+  if (pluginNote) {
+    process.stdout.write(`
+  ${pluginNote}
+`);
+  }
+  process.stdout.write(`
+  ${BOLD3}next${RESET3}
+`);
+  if (opts.link && monorepoRoot) {
+    const rootRel = path3.relative(process.cwd(), monorepoRoot) || ".";
+    const projRel = path3.relative(monorepoRoot, targetDir);
+    if (rootRel !== ".") {
+      process.stdout.write(`    cd ${rootRel}
+`);
+    }
+    process.stdout.write(`    pnpm install               ${DIM3}# picks up the new example${RESET3}
+`);
+    process.stdout.write(`    cd ${projRel}
+`);
+    process.stdout.write(
+      `    cp .env.example .env       ${DIM3}# fill in your ${envKeyFor(provider)}${RESET3}
+`
+    );
+    process.stdout.write(`    pnpm dev                   ${DIM3}# launch playground${RESET3}
+
+`);
+  } else {
+    if (rel !== ".") {
+      process.stdout.write(`    cd ${rel}
+`);
+    }
+    process.stdout.write(
+      `    cp .env.example .env       ${DIM3}# fill in your ${envKeyFor(provider)}${RESET3}
+`
+    );
+    process.stdout.write(`    pnpm install
+`);
+    process.stdout.write(`    pnpm dev                   ${DIM3}# launch playground${RESET3}
+
+`);
+  }
+}
+async function promptName() {
+  const answer = await text2({
+    message: "project name",
+    placeholder: "my-agents",
+    validate: (v) => v.trim().length === 0 ? "name is required" : void 0
+  });
+  if (isCancel2(answer)) return null;
+  return String(answer).trim();
+}
+function renderPackageJson(name, provider, link) {
+  const providerDep = providerSdkPackage(provider);
+  const apVersion = link ? "workspace:*" : "^0.1.0";
+  const pkg = {
+    name,
+    private: true,
+    version: "0.0.1",
+    type: "module",
+    scripts: {
+      dev: "ap playground",
+      start: "ap playground",
+      agents: "ap agents"
+    },
+    dependencies: {
+      "@agentic-patterns/core": apVersion,
+      "@agentic-patterns/runtime": apVersion,
+      "@agentic-patterns/cli": apVersion,
+      ai: "^4.0.0",
+      [providerDep]: "^1.0.0",
+      zod: "^3.23.0"
+    },
+    devDependencies: {
+      "@types/node": "^22.0.0",
+      typescript: "^5.7.0"
+    }
+  };
+  return `${JSON.stringify(pkg, null, 2)}
+`;
+}
+function renderEnvExample(provider) {
+  const lines = [
+    "# Dashboard URL \u2014 used by the Claude Code plugin to ship lifecycle events",
+    "AP_DASHBOARD_URL=http://localhost:3000",
+    "",
+    "# Default model tier \u2014 opus | sonnet | haiku (used by the agent runner)",
+    "AGENT_TIER=sonnet",
+    ""
+  ];
+  if (provider === "anthropic") {
+    lines.push("# Anthropic API key (https://console.anthropic.com/)");
+    lines.push("ANTHROPIC_API_KEY=sk-ant-...");
+  } else if (provider === "openai") {
+    lines.push("# OpenAI API key (https://platform.openai.com/api-keys)");
+    lines.push("OPENAI_API_KEY=sk-...");
+  } else {
+    lines.push("# Ollama host (default http://localhost:11434)");
+    lines.push("OLLAMA_HOST=http://localhost:11434");
+  }
+  return `${lines.join("\n")}
+`;
+}
+function renderTsConfig() {
+  const cfg = {
+    compilerOptions: {
+      target: "es2022",
+      module: "nodenext",
+      moduleResolution: "nodenext",
+      lib: ["es2022"],
+      outDir: "dist",
+      rootDir: "src",
+      strict: true,
+      noUncheckedIndexedAccess: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      resolveJsonModule: true,
+      declaration: true,
+      sourceMap: true
+    },
+    include: ["agents/**/*.ts", "src/**/*.ts"],
+    exclude: ["node_modules", "dist"]
+  };
+  return `${JSON.stringify(cfg, null, 2)}
+`;
+}
+function renderAgent(provider) {
+  return `/**
+ * Demo agent \u2014 generated by \`ap init\`.
+ *
+ * The default export is an AgentRegistration. The \`ap\` CLI discovers this
+ * file (via \`agents/**\\/agent.ts\`), builds a runner from your environment
+ * (using ${provider}), and wires it into the playground dashboard.
+ *
+ *   pnpm dev          # launch the dashboard at http://localhost:3000
+ *   ap run demo       # chat with this agent in the terminal
+ */
+
+import {
+  AgentBuilder,
+  Capability,
+  Judgment,
+  Mission,
+  Persona,
+  Responsibility,
+  RoleBuilder,
+  type ToolDefinition,
+  Toolbox,
+} from "@agentic-patterns/core";
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// A tiny toolbox so the agent has something concrete to do.
+// ---------------------------------------------------------------------------
+
+class GreetingToolbox extends Toolbox {
+  readonly name = "greeting_tools";
+  readonly description = "Friendly greeting helpers";
+
+  readonly tools: Record<string, ToolDefinition> = {
+    greet: {
+      description: "Produce a friendly greeting for a person",
+      parameters: z.object({
+        name: z.string().describe("Person's name"),
+      }),
+      execute: async (args) => {
+        const { name } = args as { name: string };
+        return { greeting: \`Hello, \${name}! Welcome to agentic-patterns.\` };
+      },
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Build the agent.
+// ---------------------------------------------------------------------------
+
+const role = new RoleBuilder("demo-assistant")
+  .withPersona(
+    new Persona({
+      identity: "A friendly demo assistant that greets people warmly",
+      tone: "warm and concise",
+      priorities: ["being helpful", "showing the framework off"],
+      principles: ["Always use the greet tool when greeting someone"],
+    }),
+  )
+  .withJudgment(
+    new Judgment({
+      domain: "greetings and small talk",
+      heuristics: ["Use the greet tool for any name-based greeting"],
+      constraints: ["Stay friendly and concise"],
+    }),
+  )
+  .withCapability(
+    new Capability("greeting_tools", "Friendly greeting helpers", new GreetingToolbox()),
+  )
+  .withResponsibility(
+    new Responsibility({
+      key: "greet",
+      name: "Greet People",
+      description: "Greet people warmly using the greet tool",
+    }),
+  )
+  .withDefaultModel("sonnet")
+  .build();
+
+const mission = new Mission({
+  objective: "Demonstrate the @agentic-patterns/core building blocks end-to-end",
+  success_criteria: ["Greets users by name", "Uses the greet tool for every greeting"],
+});
+
+const agent = new AgentBuilder(role).withMission(mission).build();
+
+// ---------------------------------------------------------------------------
+// Default export \u2014 discovered by \`ap\`. The runner is injected by the CLI.
+// ---------------------------------------------------------------------------
+
+export default {
+  id: "demo",
+  name: "Demo",
+  description: "A friendly demo assistant generated by \`ap init\`",
+  agent,
+};
+`;
+}
+function envKeyFor(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "openai":
+      return "OPENAI_API_KEY";
+    case "ollama":
+      return "OLLAMA_HOST";
+  }
+}
+function providerSdkPackage(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "@ai-sdk/anthropic";
+    case "openai":
+      return "@ai-sdk/openai";
+    case "ollama":
+      return "ollama-ai-provider";
+  }
+}
+function writeFile(root, rel, contents, log) {
+  const dest = path3.join(root, rel);
+  fs2.mkdirSync(path3.dirname(dest), { recursive: true });
+  fs2.writeFileSync(dest, contents, "utf8");
+  log.push(rel);
+}
+function copyDir(src, dest) {
+  fs2.cpSync(src, dest, { recursive: true });
+}
+function resolvePluginSource() {
+  const root = resolveMonorepoRoot();
+  if (!root) return null;
+  return { pluginDir: path3.join(root, ".claude-plugin"), hooksDir: path3.join(root, "hooks") };
+}
+function resolveMonorepoRoot() {
+  try {
+    const here = path3.dirname(fileURLToPath(import.meta.url));
+    let cur = here;
+    for (let i = 0; i < 8; i++) {
+      if (fs2.existsSync(path3.join(cur, "pnpm-workspace.yaml")) && fs2.existsSync(path3.join(cur, "packages", "agent-core"))) {
+        return cur;
+      }
+      const parent = path3.dirname(cur);
+      if (parent === cur) break;
+      cur = parent;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/playground.ts
+import { spawn } from "child_process";
+import { createReadStream, existsSync, statSync } from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import {
+  AgentEventBus,
+  InMemoryAdminService,
+  InMemoryEventCollector,
+  SSEExporter,
+  createRunner,
+  createToolboxExecutor
+} from "@agentic-patterns/runtime";
+import { createServer } from "@agentic-patterns/server";
+import { serve } from "@hono/node-server";
+async function runPlaygroundCommand(opts) {
+  const port = opts.port ?? 3e3;
+  const shouldOpen = opts.open !== false;
+  const serveDashboard = opts.noDashboard !== true;
+  const eventBus = new AgentEventBus();
+  const collector = new InMemoryEventCollector();
+  collector.attach(eventBus);
+  const adminService = new InMemoryAdminService(collector);
+  const sseExporter = new SSEExporter();
+  sseExporter.attach(eventBus);
+  const selection = await createRunner({
+    eventBus,
+    tier: process.env.AGENT_TIER ?? "sonnet",
+    verbose: false
+  });
+  const { runner } = selection;
+  const registrations = opts.agents.map((reg) => ({
+    id: reg.id,
+    name: reg.name,
+    description: reg.description,
+    agent: reg.agent,
+    runner
+  }));
+  void createToolboxExecutor;
+  const app = createServer({
+    agents: registrations,
+    adminService,
+    eventBus,
+    sseExporter
+  });
+  const dashboardDir = resolveDashboardDir();
+  let dashboardMounted = false;
+  if (serveDashboard) {
+    if (dashboardDir && existsSync(dashboardDir)) {
+      mountDashboard(app, dashboardDir);
+      dashboardMounted = true;
+    } else {
+      const where = dashboardDir ?? "<unresolved>";
+      process.stderr.write(
+        `[playground] warning: dashboard assets not found at ${where} \u2014 API-only mode.
+           run \`pnpm --filter @agentic-patterns/cli build\` (or \`build:dashboard\`) to build the SPA bundle.
+`
+      );
+    }
+  }
+  await new Promise((resolve) => {
+    serve({ fetch: app.fetch, port }, () => {
+      resolve();
+    });
+  });
+  const baseUrl = `http://localhost:${port}`;
+  const agentList = registrations.map((a) => a.name).join(", ") || "(none)";
+  const lines = [
+    "",
+    `  api        ${baseUrl}`,
+    dashboardMounted ? `  dashboard  ${baseUrl}` : "  dashboard  (disabled)",
+    `  agents     ${agentList}`,
+    `  runner     ${selection.source} \u2014 ${selection.reason}`,
+    ""
+  ];
+  process.stdout.write(`${lines.join("\n")}
+`);
+  if (shouldOpen && dashboardMounted) {
+    openBrowser(baseUrl);
+  }
+}
+function resolveDashboardDir() {
+  try {
+    const here = path4.dirname(fileURLToPath2(import.meta.url));
+    return path4.resolve(here, "../assets/dashboard");
+  } catch {
+    return null;
+  }
+}
+var API_PREFIXES = ["/agents", "/conversations", "/admin", "/health"];
+function isApiPath(pathname) {
+  return API_PREFIXES.some((p) => pathname === p || pathname.startsWith(`${p}/`));
+}
+function mountDashboard(app, dashboardDir) {
+  const indexPath = path4.join(dashboardDir, "index.html");
+  app.get("*", async (c) => {
+    if (c.req.method !== "GET") {
+      return c.notFound();
+    }
+    const url = new URL(c.req.url);
+    const pathname = decodeURIComponent(url.pathname);
+    if (isApiPath(pathname)) {
+      return c.notFound();
+    }
+    const assetPath = pathname === "/" ? indexPath : safeJoin(dashboardDir, pathname);
+    if (assetPath && existsSync(assetPath) && statSync(assetPath).isFile()) {
+      return streamFile(assetPath);
+    }
+    if (existsSync(indexPath)) {
+      return streamFile(indexPath);
+    }
+    return c.notFound();
+  });
+}
+function safeJoin(base, rel) {
+  const joined = path4.join(base, rel);
+  const normalizedBase = path4.resolve(base);
+  const normalizedJoined = path4.resolve(joined);
+  if (normalizedJoined !== normalizedBase && !normalizedJoined.startsWith(`${normalizedBase}${path4.sep}`)) {
+    return null;
+  }
+  return normalizedJoined;
+}
+function streamFile(filePath) {
+  const ext = path4.extname(filePath).toLowerCase();
+  const contentType = MIME[ext] ?? "application/octet-stream";
+  const nodeStream = createReadStream(filePath);
+  const webStream = new ReadableStream({
+    start(controller) {
+      nodeStream.on("data", (chunk) => {
+        const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
+        controller.enqueue(bytes);
+      });
+      nodeStream.on("end", () => controller.close());
+      nodeStream.on("error", (err) => controller.error(err));
+    },
+    cancel() {
+      nodeStream.destroy();
+    }
+  });
+  return new Response(webStream, {
+    status: 200,
+    headers: { "content-type": contentType }
+  });
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8"
+};
+function openBrowser(url) {
+  const { platform } = process;
+  const { cmd, args } = platform === "darwin" ? { cmd: "open", args: [url] } : platform === "win32" ? { cmd: "cmd", args: ["/c", "start", "", url] } : { cmd: "xdg-open", args: [url] };
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/commands/run.ts
+import {
+  Conversation,
+  createRunner as createRunner2,
+  createToolboxExecutor as createToolboxExecutor2,
+  getAgentEventBus
+} from "@agentic-patterns/runtime";
+import { isCancel as isCancel3, text as text3 } from "@clack/prompts";
+async function runRunCommand(opts) {
+  const reg = opts.agents.find((a) => a.id === opts.agentId);
+  if (!reg) {
+    const available = opts.agents.map((a) => a.id).join(", ") || "(none)";
+    process.stderr.write(
+      `${red(`agent "${opts.agentId}" not found`)}
+  available: ${available}
+`
+    );
+    process.exit(1);
+  }
+  const eventBus = getAgentEventBus();
+  const { runner } = await createRunner2({ eventBus, verbose: false });
+  const conversation = new Conversation(reg.agent, runner, {
+    toolExecutor: createToolboxExecutor2(reg.agent)
+  });
+  if (opts.message !== void 0) {
+    await streamOnce(conversation, opts.message);
+    return;
+  }
+  await runRepl(conversation, reg);
+}
+async function streamOnce(conversation, message) {
+  const controller = new AbortController();
+  const onSigint = () => {
+    controller.abort();
+  };
+  process.on("SIGINT", onSigint);
+  try {
+    await renderStream(conversation.stream(message), controller.signal);
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+}
+async function runRepl(conversation, reg) {
+  const banner = `chatting with ${bold(reg.agent.role.name)} ${dim("\xB7")} ${dim(
+    "type /exit to quit"
+  )}`;
+  process.stdout.write(`${banner}
+
+`);
+  for (; ; ) {
+    const input = await text3({ message: "you" });
+    if (isCancel3(input)) {
+      process.stdout.write(`${dim("bye.")}
+`);
+      return;
+    }
+    const line = input.trim();
+    if (line === "") continue;
+    if (line === "/exit" || line === "/quit") {
+      process.stdout.write(`${dim("bye.")}
+`);
+      return;
+    }
+    const controller = new AbortController();
+    const onSigint = () => {
+      controller.abort();
+    };
+    process.on("SIGINT", onSigint);
+    try {
+      await renderStream(conversation.stream(line), controller.signal);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stdout.write(`
+${red(`error: ${msg}`)}
+`);
+    } finally {
+      process.off("SIGINT", onSigint);
+    }
+    process.stdout.write("\n");
+  }
+}
+async function renderStream(stream, signal) {
+  let inThinking = false;
+  for await (const event of stream) {
+    if (signal.aborted) {
+      await safeReturn(stream);
+      process.stdout.write(`
+${yellow("aborted.")}
+`);
+      return;
+    }
+    inThinking = renderEvent(event, inThinking);
+  }
+}
+function renderEvent(event, inThinking) {
+  switch (event.type) {
+    case "agent.message.start":
+      process.stdout.write(`${bold("assistant")}: `);
+      return inThinking;
+    case "agent.message.chunk":
+      process.stdout.write(event.delta);
+      return inThinking;
+    case "agent.thinking.start":
+      process.stdout.write(`
+  ${dim("\u{1F4AD} thinking\u2026")}
+`);
+      return true;
+    case "agent.reasoning":
+      if (event.isComplete) {
+        process.stdout.write("\n");
+        return false;
+      }
+      process.stdout.write(`  ${dim(`\u{1F4AD} ${event.content}`)}
+`);
+      return true;
+    case "agent.tool.start": {
+      const args = formatArgs(event.arguments);
+      process.stdout.write(`
+  ${cyan(`\u{1F527} ${event.toolName}(${args})`)}
+`);
+      return inThinking;
+    }
+    case "agent.tool.end": {
+      if (event.error) {
+        process.stdout.write(`     ${red(`\u2717 ${event.error}`)}
+`);
+      } else {
+        const preview = previewResult(event.result);
+        process.stdout.write(`     ${dim(`\u2192 ${preview}`)}
+`);
+      }
+      return inThinking;
+    }
+    case "agent.message.complete": {
+      const footer = `${event.model} \xB7 ${event.inputTokens}\u2193 ${event.outputTokens}\u2191`;
+      process.stdout.write(`
+${dim(footer)}
+`);
+      return inThinking;
+    }
+    case "agent.error":
+      process.stdout.write(`
+  ${red(`\u26A0 ${event.errorType}: ${event.message}`)}
+`);
+      return inThinking;
+    default:
+      return inThinking;
+  }
+}
+async function safeReturn(stream) {
+  try {
+    await stream.return(void 0);
+  } catch {
+  }
+}
+function formatArgs(args) {
+  try {
+    const entries = Object.entries(args);
+    if (entries.length === 0) return "";
+    const parts = entries.map(([k, v]) => `${k}=${shortJson(v)}`);
+    const joined = parts.join(", ");
+    return joined.length > 120 ? `${joined.slice(0, 117)}...` : joined;
+  } catch {
+    return "\u2026";
+  }
+}
+function previewResult(result) {
+  const s = typeof result === "string" ? result : shortJson(result);
+  const oneLine = s.replace(/\s+/g, " ").trim();
+  return oneLine.length > 240 ? `${oneLine.slice(0, 237)}...` : oneLine;
+}
+function shortJson(v) {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function bold(s) {
+  return `\x1B[1m${s}\x1B[0m`;
+}
+function dim(s) {
+  return `\x1B[2m${s}\x1B[0m`;
+}
+function cyan(s) {
+  return `\x1B[36m${s}\x1B[0m`;
+}
+function red(s) {
+  return `\x1B[31m${s}\x1B[0m`;
+}
+function yellow(s) {
+  return `\x1B[33m${s}\x1B[0m`;
+}
+
+// src/commands/status.ts
+import path5 from "path";
+var BOLD4 = "\x1B[1m";
+var DIM4 = "\x1B[2m";
+var RESET4 = "\x1B[0m";
+var GREEN3 = "\x1B[32m";
+var YELLOW3 = "\x1B[33m";
+function runStatusCommand(input) {
+  const { config, agents, loadErrors } = input;
+  const runner = detectRunnerFromEnv();
+  const lines = [];
+  lines.push("");
+  lines.push(`${BOLD4}agentic-patterns${RESET4}`);
+  lines.push("");
+  lines.push(formatAgentsRow(agents, config.root));
+  for (const a of agents) {
+    lines.push(`            ${GREEN3}\u25CF${RESET4} ${a.id}`);
+  }
+  if (loadErrors.length > 0) {
+    for (const err of loadErrors) {
+      lines.push(`            ${YELLOW3}!${RESET4} ${err.file}: ${err.error.message}`);
+    }
+  }
+  lines.push(`  runner    ${runner.provider}  ${DIM4}(${runner.detail})${RESET4}`);
+  lines.push(`  config    ${formatConfigRow(config)}`);
+  lines.push("");
+  lines.push(`  ${DIM4}ap run <agent> \xB7 ap playground \xB7 ap -h${RESET4}`);
+  lines.push("");
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+function formatAgentsRow(agents, root) {
+  const count = agents.length;
+  if (count === 0) {
+    return `  agents    ${DIM4}none discovered (looked in ${path5.relative(process.cwd(), root) || "."}/agents/)${RESET4}`;
+  }
+  return `  agents    ${count} discovered  ${DIM4}(./agents/)${RESET4}`;
+}
+function formatConfigRow(config) {
+  const parts = [];
+  if (config.hasManifest) parts.push("package.json overrides");
+  parts.push("see ap config");
+  return parts.join(" \xB7 ");
+}
+function detectRunnerFromEnv() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { provider: "anthropic", detail: "env ANTHROPIC_API_KEY \u2192 claude-sonnet-4-5" };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return { provider: "openai", detail: "env OPENAI_API_KEY \u2192 gpt-4o" };
+  }
+  if (process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY) {
+    return { provider: "google", detail: "env GOOGLE_*_API_KEY \u2192 gemini-2.5-flash" };
+  }
+  if (process.env.OLLAMA_HOST) {
+    const tier = process.env.AGENT_TIER ?? "sonnet";
+    const model = tier === "opus" ? "qwen3:30b-a3b" : tier === "haiku" ? "qwen3:4b" : "qwen3:14b";
+    return {
+      provider: "ollama",
+      detail: `env OLLAMA_HOST \u2192 ${model} (tier=${tier})`
+    };
+  }
+  return {
+    provider: `${YELLOW3}none${RESET4}`,
+    detail: "set ANTHROPIC_API_KEY, OLLAMA_HOST, or have `claude` CLI on PATH"
+  };
+}
+
+// src/helpers/config.ts
+import fs3 from "fs";
+import path6 from "path";
+var DEFAULT_AGENT_GLOBS = ["agents/**/agent.{ts,js,mjs}"];
+function findProjectRoot(from = process.cwd()) {
+  let dir = path6.resolve(from);
+  while (true) {
+    if (fs3.existsSync(path6.join(dir, "package.json"))) return dir;
+    const parent = path6.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadDotEnv(root) {
+  const file = path6.join(root, ".env");
+  if (!fs3.existsSync(file)) return;
+  const text4 = fs3.readFileSync(file, "utf-8");
+  for (const rawLine of text4.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim().replace(/^["'](.*)["']$/, "$1");
+    if (process.env[key] === void 0) process.env[key] = value;
+  }
+}
+function resolveProjectConfig(from = process.cwd()) {
+  const root = findProjectRoot(from) ?? from;
+  loadDotEnv(root);
+  let manifest = {};
+  let hasManifest = false;
+  const pkgPath = path6.join(root, "package.json");
+  if (fs3.existsSync(pkgPath)) {
+    try {
+      const parsed = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+      manifest = parsed;
+      hasManifest = Boolean(parsed.agentic);
+    } catch {
+    }
+  }
+  const agents = normalizeGlobs(manifest.agentic?.agents) ?? DEFAULT_AGENT_GLOBS;
+  const port = manifest.agentic?.port ?? Number.parseInt(process.env.PORT ?? "3000", 10);
+  return { root, agents, port, hasManifest };
+}
+function normalizeGlobs(value) {
+  if (!value) return void 0;
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/helpers/discover.ts
+import path7 from "path";
+import { pathToFileURL } from "url";
+import { glob } from "tinyglobby";
+import { register } from "tsx/esm/api";
+var _tsxRegistered = false;
+function ensureTsxRegistered() {
+  if (_tsxRegistered) return;
+  register();
+  _tsxRegistered = true;
+}
+async function findAgentFiles(root, globs) {
+  const matches = await glob([...globs], {
+    cwd: root,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  return matches.sort();
+}
+async function loadAgentFile(file) {
+  const isTs = file.endsWith(".ts") || file.endsWith(".tsx") || file.endsWith(".mts");
+  if (isTs) ensureTsxRegistered();
+  const mod = await import(pathToFileURL(file).href);
+  let exported = mod.default;
+  if (typeof exported === "function") {
+    exported = await exported();
+  }
+  if (!exported || typeof exported !== "object") {
+    throw new Error(
+      `${file}: default export must be an AgentRegistration object or a function returning one`
+    );
+  }
+  const { id, name, description, agent } = exported;
+  if (!id || typeof id !== "string") {
+    throw new Error(`${file}: missing or invalid 'id' (must be a non-empty string)`);
+  }
+  if (!name || typeof name !== "string") {
+    throw new Error(`${file}: missing or invalid 'name' (must be a non-empty string)`);
+  }
+  if (!agent || typeof agent !== "object") {
+    throw new Error(`${file}: missing or invalid 'agent' (must be an Agent object)`);
+  }
+  return {
+    id,
+    name,
+    description,
+    agent,
+    file
+  };
+}
+async function discoverAgents(root, globs) {
+  const files = await findAgentFiles(root, globs);
+  const agents = [];
+  const errors = [];
+  for (const file of files) {
+    try {
+      const a = await loadAgentFile(file);
+      agents.push(a);
+    } catch (e) {
+      errors.push({
+        file: path7.relative(root, file),
+        error: e instanceof Error ? e : new Error(String(e))
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const a of agents) {
+    if (seen.has(a.id)) {
+      errors.push({
+        file: path7.relative(root, a.file),
+        error: new Error(`duplicate agent id "${a.id}" (already registered)`)
+      });
+    } else {
+      seen.add(a.id);
+      deduped.push(a);
+    }
+  }
+  return { agents: deduped, errors };
+}
+
+// src/cli.ts
+var USAGE = `
+ap \u2014 agentic patterns
+
+Usage:
+  ap                              status dashboard
+  ap <command> [options]
+
+Commands:
+  agents                          list discovered agents
+  run <agent> [message]           chat in terminal \u2014 interactive or one-shot
+  playground                      launch UI environment (server + dashboard)
+  init [<dir>]                    scaffold a new agent project
+  config                          show env detection status
+  config set                      interactive .env editor
+
+Options:
+  -h, --help                      show this help
+  --port <port>                   server port for playground (default 3000)
+  --no-dashboard                  playground without dashboard (API only)
+  --no-open                       don't auto-open the browser
+  --agents <glob>                 override agent discovery glob
+  --with-plugin                   (init) drop the Claude Code plugin too
+  --provider <p>                  (init) anthropic | openai | ollama
+  --link                          (init) use file: deps against the local
+                                    monorepo (dogfooding before publish)
+`;
+async function main() {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      help: { type: "boolean", short: "h" },
+      port: { type: "string" },
+      "no-dashboard": { type: "boolean" },
+      "no-open": { type: "boolean" },
+      agents: { type: "string" },
+      "with-plugin": { type: "boolean" },
+      provider: { type: "string" },
+      link: { type: "boolean" }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  if (values.help) {
+    process.stdout.write(`${USAGE}
+`);
+    return;
+  }
+  const command = positionals[0];
+  if (command === "init") {
+    const targetDir = positionals[1];
+    const providerRaw = values.provider ? String(values.provider) : void 0;
+    await runInitCommand({
+      targetDir,
+      withPlugin: Boolean(values["with-plugin"]),
+      provider: providerRaw,
+      link: Boolean(values.link)
+    });
+    return;
+  }
+  const config = resolveProjectConfig();
+  const globs = values.agents ? [String(values.agents)] : config.agents;
+  const { agents, errors } = await discoverAgents(config.root, globs);
+  switch (command) {
+    case void 0: {
+      runStatusCommand({ config, agents, loadErrors: errors });
+      return;
+    }
+    case "agents": {
+      runAgentsCommand({ agents, loadErrors: errors, root: config.root });
+      return;
+    }
+    case "run": {
+      const agentId = positionals[1];
+      if (!agentId) {
+        process.stderr.write(`error: ap run requires an agent id
+${USAGE}
+`);
+        process.exit(1);
+      }
+      const message = positionals.slice(2).join(" ") || void 0;
+      await runRunCommand({ agents, agentId, message });
+      return;
+    }
+    case "playground": {
+      const port = values.port ? Number.parseInt(String(values.port), 10) : config.port;
+      await runPlaygroundCommand({
+        agents,
+        port,
+        noDashboard: Boolean(values["no-dashboard"]),
+        open: !values["no-open"]
+      });
+      return;
+    }
+    case "config": {
+      const sub = positionals[1];
+      if (sub === "set") {
+        await runConfigSetCommand({ config });
+      } else if (sub === void 0) {
+        runConfigStatusCommand({ config });
+      } else {
+        process.stderr.write(`error: unknown config subcommand "${sub}"
+${USAGE}
+`);
+        process.exit(1);
+      }
+      return;
+    }
+    default: {
+      process.stderr.write(`error: unknown command "${command}"
+${USAGE}
+`);
+      process.exit(1);
+    }
+  }
+}
+main().catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`\x1B[31merror:\x1B[0m ${msg}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map