agentnetes 0.1.0

package/dist/index.js

@@ -0,0 +1,1018 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_child_process4 = require("child_process");
+
+// src/commands/run.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_picocolors2 = __toESM(require("picocolors"));
+
+// ../../lib/vrlm/runtime.ts
+var import_ai2 = require("ai");
+var import_zod2 = require("zod");
+
+// ../../lib/gateway.ts
+var import_gateway = require("@ai-sdk/gateway");
+var import_google = require("@ai-sdk/google");
+function makeProvider() {
+  if (process.env.AI_GATEWAY_BASE_URL) {
+    return (0, import_gateway.createGatewayProvider)({ baseURL: process.env.AI_GATEWAY_BASE_URL });
+  }
+  return (0, import_google.createGoogleGenerativeAI)({
+    apiKey: process.env.GOOGLE_API_KEY ?? process.env.GOOGLE_GENERATIVE_AI_API_KEY
+  });
+}
+var provider = makeProvider();
+function gateway(model) {
+  if (process.env.AI_GATEWAY_BASE_URL) {
+    return provider(model);
+  }
+  const modelId = model.includes("/") ? model.split("/").slice(1).join("/") : model;
+  return provider(modelId);
+}
+
+// ../../lib/vrlm/tools.ts
+var import_ai = require("ai");
+var import_zod = require("zod");
+function createAgentTools(sandbox) {
+  const search = (0, import_ai.tool)({
+    description: "Search for patterns across the codebase. Returns matching file paths. Use this to locate where interfaces, types, functions, and patterns are defined.",
+    inputSchema: import_zod.z.object({
+      pattern: import_zod.z.string().describe("The regex or literal pattern to search for"),
+      path: import_zod.z.string().optional().describe("Directory to search in (default: current dir)"),
+      fileGlob: import_zod.z.string().optional().describe('Glob for file types, e.g. "*.ts" or "*.json"')
+    }),
+    execute: async ({ pattern, path = ".", fileGlob }) => {
+      const include = fileGlob ? `--include="${fileGlob}"` : "";
+      const cmd = `grep -r ${JSON.stringify(pattern)} ${path} ${include} -l 2>/dev/null | head -40 || true`;
+      const result = await sandbox.runCommand("bash", ["-c", cmd]);
+      const out = (await result.stdout()).trim();
+      return out || "(no matches)";
+    }
+  });
+  const execute = (0, import_ai.tool)({
+    description: "Execute any shell command in the isolated sandbox. Use to read files (cat), list directories (ls/find), run tests (vitest), compile (tsc), write files (tee), install packages, etc.",
+    inputSchema: import_zod.z.object({
+      command: import_zod.z.string().describe("The shell command to execute")
+    }),
+    execute: async ({ command: command2 }) => {
+      const cmd = `(${command2}) 2>&1 | head -200`;
+      const result = await sandbox.runCommand("bash", ["-c", cmd]);
+      const output = (await result.stdout()).trim();
+      return {
+        output: output || "(no output)",
+        exitCode: result.exitCode
+      };
+    }
+  });
+  return { search, execute };
+}
+
+// ../../lib/vrlm/local-sandbox.ts
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+var LocalSandbox = class {
+  id = "local";
+  dir;
+  constructor(dir) {
+    this.dir = dir;
+  }
+  async runCommand(shell, args2) {
+    const cmd = args2.join(" ");
+    try {
+      const output = (0, import_child_process.execSync)(cmd, {
+        cwd: this.dir,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      return { stdout: async () => output ?? "", exitCode: 0 };
+    } catch (err) {
+      const out = (err.stdout ?? "") + (err.stderr ?? "") || (err.message ?? "");
+      return { stdout: async () => out, exitCode: err.status ?? 1 };
+    }
+  }
+  async readFile({ path }) {
+    try {
+      const content = (0, import_fs.readFileSync)(path);
+      async function* gen() {
+        yield content;
+      }
+      return gen();
+    } catch {
+      return null;
+    }
+  }
+  async stop() {
+    try {
+      (0, import_fs.rmSync)(this.dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+};
+async function createLocalSandbox(repoUrl) {
+  const dir = (0, import_fs.mkdtempSync)((0, import_path.join)((0, import_os.tmpdir)(), "agentnetes-"));
+  (0, import_child_process.execSync)(`git clone --depth 1 ${repoUrl} .`, {
+    cwd: dir,
+    timeout: 12e4,
+    stdio: "ignore"
+  });
+  return new LocalSandbox(dir);
+}
+
+// ../../lib/vrlm/docker-sandbox.ts
+var import_child_process2 = require("child_process");
+var DOCKER_IMAGE = "node:20-alpine";
+var DockerSandbox = class {
+  id;
+  containerId;
+  constructor(containerId) {
+    this.containerId = containerId;
+    this.id = `docker-${containerId.slice(0, 12)}`;
+  }
+  async runCommand(_shell, args2) {
+    const cmd = args2.join(" ");
+    try {
+      const output = (0, import_child_process2.execSync)(
+        `docker exec ${this.containerId} sh -c ${JSON.stringify(cmd)}`,
+        { encoding: "utf-8", timeout: 6e4 }
+      );
+      return { stdout: async () => output ?? "", exitCode: 0 };
+    } catch (err) {
+      const out = (err.stdout ?? "") + (err.stderr ?? "") || (err.message ?? "");
+      return { stdout: async () => out, exitCode: err.status ?? 1 };
+    }
+  }
+  async readFile({ path }) {
+    try {
+      const content = (0, import_child_process2.execSync)(`docker exec ${this.containerId} cat ${path}`, {
+        timeout: 1e4
+      });
+      async function* gen() {
+        yield content;
+      }
+      return gen();
+    } catch {
+      return null;
+    }
+  }
+  async stop() {
+    try {
+      (0, import_child_process2.execSync)(`docker rm -f ${this.containerId}`, { stdio: "ignore" });
+    } catch {
+    }
+  }
+};
+async function createDockerSandbox(repoUrl) {
+  const containerId = (0, import_child_process2.execSync)(
+    `docker run -d --rm ${DOCKER_IMAGE} sh -c "sleep 3600"`,
+    { encoding: "utf-8" }
+  ).trim();
+  (0, import_child_process2.execSync)(
+    `docker exec ${containerId} sh -c "apk add --no-cache git 2>/dev/null"`,
+    { timeout: 3e4, stdio: "ignore" }
+  );
+  (0, import_child_process2.execSync)(
+    `docker exec ${containerId} git clone --depth 1 ${repoUrl} /workspace`,
+    { timeout: 12e4, stdio: "ignore" }
+  );
+  return new DockerSandbox(containerId);
+}
+
+// ../../lib/vrlm/sandbox-manager.ts
+function detectProvider() {
+  const explicit = process.env.SANDBOX_PROVIDER?.toLowerCase();
+  if (explicit === "vercel") return "vercel";
+  if (explicit === "e2b") return "e2b";
+  if (explicit === "daytona") return "daytona";
+  if (explicit === "docker") return "docker";
+  if (explicit === "local") return "local";
+  if (process.env.VERCEL_TOKEN || process.env.VERCEL) return "vercel";
+  if (process.env.E2B_API_KEY) return "e2b";
+  if (process.env.DAYTONA_API_KEY) return "daytona";
+  return "docker";
+}
+async function createWorkerSandbox(repoUrl, snapshotId) {
+  const provider2 = detectProvider();
+  if (provider2 === "vercel") {
+    const { Sandbox: Sandbox2 } = await import("@vercel/sandbox");
+    if (snapshotId) {
+      return Sandbox2.create({ source: { type: "snapshot", snapshotId }, timeout: 10 * 60 * 1e3 });
+    }
+    return Sandbox2.create({ source: { type: "git", url: repoUrl, depth: 1 }, timeout: 10 * 60 * 1e3 });
+  }
+  if (provider2 === "e2b") {
+    console.warn('[sandbox] e2b: install the "e2b" package to use this provider. Falling back to local.');
+  }
+  if (provider2 === "daytona") {
+    console.warn('[sandbox] daytona: install the "@daytonaio/sdk" package to use this provider. Falling back to local.');
+  }
+  if (provider2 === "docker") {
+    return createDockerSandbox(repoUrl);
+  }
+  return createLocalSandbox(repoUrl);
+}
+async function collectNewFiles(sandbox, dir, extensions = ["ts", "js", "json", "md"]) {
+  const extList = extensions.map((e) => `-name "*.${e}"`).join(" -o ");
+  const findCmd = `find ${dir} \\( ${extList} \\) -type f 2>/dev/null | head -30`;
+  const result = await sandbox.runCommand("bash", ["-c", findCmd]);
+  const files = (await result.stdout()).trim().split("\n").filter(Boolean);
+  const out = [];
+  for (const filePath of files) {
+    const stream = await sandbox.readFile({ path: filePath });
+    if (!stream) continue;
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    out.push({ path: filePath, content: Buffer.concat(chunks).toString("utf-8") });
+  }
+  return out;
+}
+async function stopSandbox(sandbox) {
+  try {
+    await sandbox.stop();
+  } catch {
+  }
+}
+
+// ../../lib/vrlm/prompts.ts
+var PLANNER_SYSTEM_PROMPT = `
+You are the Tech Lead of Agentnetes, a self-organizing AI agency.
+
+Your job is to decompose a software engineering goal into a team of specialist agents.
+Each agent will run concurrently in its own isolated sandbox with access to the codebase.
+Each worker agent will explore the repo themselves before completing their task.
+
+Rules:
+- Invent roles that fit the task AND the likely shape of the repo. Do NOT use generic names like "Agent 1".
+- Each agent needs a clear, scoped goal it can complete independently.
+- Keep the team small: 3-5 agents is usually right. Never more than 6.
+- Roles must be complementary, not overlapping.
+- The first agent should always be an explorer or scout that maps the codebase structure.
+- Include a test or verification agent if the task involves writing code.
+- Choose an appropriate emoji icon for each role.
+- Tailor roles to what kind of repo this is likely to be based on the goal text.
+
+Common role patterns (adapt to the task):
+- Architecture Scout: maps the repo structure, finds relevant files and patterns
+- [Domain] Engineer: implements the core feature
+- Test Engineer: writes tests and verifies correctness
+- Package/Config Engineer: handles package.json, tsconfig, exports, build config
+- Security Scanner: finds vulnerabilities, unsafe patterns
+- Documentation Writer: writes docs, README, changelogs
+
+Respond ONLY with valid JSON in exactly this format, no markdown fences:
+{
+  "workers": [
+    {
+      "role": "Architecture Scout",
+      "goal": "Explore the repo structure. Run: find . -maxdepth 3 -type f | head -60 to map the repo. Read package.json or equivalent to detect the stack. Document relevant files and patterns for the goal.",
+      "icon": "\u{1F50D}"
+    }
+  ]
+}
+`.trim();
+function buildPlannerPrompt(goal) {
+  return `Goal: ${goal}
+
+Decompose this into a specialist agent team. Return JSON only, no markdown fences.`;
+}
+function buildWorkerPrompt(task, findings) {
+  const findingsSection = findings.length > 0 ? `
+
+Findings from other agents:
+${findings.map((f) => `- ${f}`).join("\n")}` : "";
+  return `
+You are ${task.role} in the Agentnetes swarm.
+
+Your goal: ${task.goal}
+
+You have two tools:
+- search(pattern, path?, fileGlob?): grep the codebase for patterns, returns matching file paths
+- execute(command): run any shell command in your sandbox (cat, ls, find, tsc, vitest, etc.)
+
+The codebase is available in your sandbox. Start by exploring to understand the structure, then complete your goal.
+
+Strategy:
+1. First, explore the repo: run find . -maxdepth 3 -type f | head -60 to map the layout
+2. Read package.json or equivalent config to detect the language, framework and test runner
+3. Use search() to find relevant files and patterns related to your goal
+4. Use execute() to read files (cat), run build or test commands (tsc, vitest, pytest, etc.)
+5. When writing code, use execute() with heredoc or tee to write files
+6. Run verification commands to check your work
+7. Fix any errors before completing
+
+Be methodical. Explore before implementing. Verify after implementing.
+If you encounter errors, diagnose and fix them.
+When done, provide a clear summary of everything you accomplished.${findingsSection}
+`.trim();
+}
+function buildSynthesisPrompt(goal, workerSummaries) {
+  return `
+You are the Tech Lead summarizing the results of your agent team.
+
+Original goal: ${goal}
+
+Agent results:
+${workerSummaries.map((s, i) => `Agent ${i + 1}:
+${s}`).join("\n\n")}
+
+Write a concise markdown summary covering:
+1. What was accomplished (with specific files and test results if available)
+2. Any issues encountered and how they were resolved
+3. What to do next (if anything remains)
+
+Be specific. Mention actual file names, test counts, error counts.
+`.trim();
+}
+
+// ../../lib/a2a.ts
+function slugify(role) {
+  return role.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function skillsForRole(role) {
+  const r = role.toLowerCase();
+  if (r.includes("scout") || r.includes("explorer") || r.includes("architect")) {
+    return [
+      {
+        id: "explore-codebase",
+        name: "Explore Codebase",
+        description: "Scans a repository and documents architecture patterns, interface contracts, and file conventions",
+        tags: ["codebase", "architecture", "typescript", "monorepo"],
+        examples: [
+          "Explore the provider package structure in vercel/ai",
+          "Document interface contracts for LanguageModelV1",
+          "Find all test patterns across packages"
+        ]
+      },
+      {
+        id: "map-dependencies",
+        name: "Map Dependencies",
+        description: "Traces dependency graphs across a monorepo and identifies shared utilities",
+        tags: ["dependencies", "monorepo", "pnpm"],
+        examples: ["Map all workspace dependencies in vercel/ai", "Find all packages that depend on @ai-sdk/provider"]
+      }
+    ];
+  }
+  if (r.includes("provider") || r.includes("implement") || r.includes("engineer")) {
+    return [
+      {
+        id: "implement-provider",
+        name: "Implement Provider",
+        description: "Creates a new AI SDK provider package following existing patterns \u2014 provider class, chat model, streaming",
+        tags: ["typescript", "ai-sdk", "provider", "streaming"],
+        examples: [
+          "Add @ai-sdk/deepseek with streaming and reasoning tokens",
+          "Implement a new OpenAI-compatible provider",
+          "Add tool-calling support to an existing provider"
+        ]
+      },
+      {
+        id: "implement-feature",
+        name: "Implement Feature",
+        description: "Builds a software feature in an existing codebase following discovered conventions",
+        tags: ["typescript", "implementation", "feature"],
+        examples: ["Add a /research command to a CLI tool", "Implement a new API endpoint following existing patterns"]
+      }
+    ];
+  }
+  if (r.includes("test") || r.includes("verif") || r.includes("qa")) {
+    return [
+      {
+        id: "write-tests",
+        name: "Write Tests",
+        description: "Writes comprehensive tests following the codebase test conventions \u2014 unit, integration, streaming",
+        tags: ["vitest", "testing", "typescript", "coverage"],
+        examples: [
+          "Write tests for a new provider package",
+          "Add streaming tests for a chat model",
+          "Write integration tests for a new API endpoint"
+        ]
+      },
+      {
+        id: "run-verification",
+        name: "Run Verification",
+        description: "Runs tests, type checks, and linting to verify correctness. Reports failures with context.",
+        tags: ["typescript", "vitest", "tsc", "verification"],
+        examples: ["Verify TypeScript compilation passes", "Run all tests and report failures"]
+      }
+    ];
+  }
+  if (r.includes("package") || r.includes("config") || r.includes("integrat")) {
+    return [
+      {
+        id: "setup-package",
+        name: "Setup Package",
+        description: "Configures package.json, tsconfig.json, exports, and monorepo wiring for a new package",
+        tags: ["monorepo", "pnpm", "typescript", "package"],
+        examples: [
+          "Set up a new @ai-sdk/* package from scratch",
+          "Configure ESM + CJS dual exports",
+          "Wire a new package into pnpm workspace"
+        ]
+      }
+    ];
+  }
+  if (r.includes("security") || r.includes("scanner") || r.includes("auth") || r.includes("risk")) {
+    return [
+      {
+        id: "security-audit",
+        name: "Security Audit",
+        description: "Analyzes code for security vulnerabilities \u2014 auth flows, input validation, dependency CVEs",
+        tags: ["security", "audit", "vulnerabilities", "owasp"],
+        examples: [
+          "Audit authentication flows for session fixation",
+          "Scan dependencies for known CVEs",
+          "Find XSS vulnerabilities in user input handling"
+        ]
+      }
+    ];
+  }
+  return [
+    {
+      id: "general-task",
+      name: "General Engineering Task",
+      description: "Performs software engineering tasks \u2014 exploration, implementation, verification",
+      tags: ["typescript", "engineering"],
+      examples: ["Implement a requested feature following existing patterns"]
+    }
+  ];
+}
+function buildA2ACard(task) {
+  const slug = slugify(task.role);
+  return {
+    name: task.role,
+    description: task.goal,
+    url: `https://agentnetes.vercel.app/agents/${slug}`,
+    version: "1.0.0",
+    provider: { organization: "Agentnetes" },
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: true
+    },
+    authentication: { schemes: ["bearer"] },
+    defaultInputModes: ["text/plain", "application/json"],
+    defaultOutputModes: ["text/plain", "application/json"],
+    skills: skillsForRole(task.role)
+  };
+}
+
+// ../../lib/vrlm/runtime.ts
+var WorkerPlanSchema = import_zod2.z.object({
+  workers: import_zod2.z.array(
+    import_zod2.z.object({
+      role: import_zod2.z.string(),
+      goal: import_zod2.z.string(),
+      icon: import_zod2.z.string().default("\u{1F916}")
+    })
+  )
+});
+function uid() {
+  return crypto.randomUUID();
+}
+function detectLanguage(filename) {
+  const ext = filename.split(".").pop() ?? "";
+  const map = {
+    ts: "typescript",
+    tsx: "tsx",
+    js: "javascript",
+    jsx: "jsx",
+    json: "json",
+    md: "markdown",
+    sh: "bash",
+    py: "python"
+  };
+  return map[ext] ?? "text";
+}
+var VrlmRuntime = class {
+  emitter;
+  config;
+  constructor(emitter, config) {
+    this.emitter = emitter;
+    this.config = config;
+  }
+  async run(goal) {
+    const snapshotId = this.config.repoSnapshotId;
+    const repoUrl = this.config.repoUrl;
+    try {
+      const rootTask = this.makeTask({
+        role: "Tech Lead",
+        goal: `Plan and coordinate: ${goal}`,
+        icon: "\u{1F9E0}",
+        depth: 0,
+        parentId: null
+      });
+      this.emitTaskCreated(rootTask);
+      this.emitTaskUpdate(rootTask.id, "running", "Planning agent team...");
+      const plan = await this.runPlanner(goal);
+      this.emitTaskUpdate(rootTask.id, "running", `Spawning ${plan.workers.length} agents`);
+      const workerTasks = plan.workers.slice(0, this.config.maxWorkers).map(
+        (w) => this.makeTask({
+          role: w.role,
+          goal: w.goal,
+          icon: w.icon,
+          depth: 1,
+          parentId: rootTask.id
+        })
+      );
+      for (const task of workerTasks) {
+        rootTask.children.push(task.id);
+        this.emitTaskCreated(task);
+      }
+      const workerResults = await Promise.allSettled(
+        workerTasks.map((task) => this.runWorker(task, repoUrl, snapshotId))
+      );
+      const summaries = [];
+      for (let i = 0; i < workerResults.length; i++) {
+        const result = workerResults[i];
+        if (result.status === "fulfilled") {
+          summaries.push(`${workerTasks[i].role}: ${result.value}`);
+        } else {
+          summaries.push(`${workerTasks[i].role}: FAILED - ${result.reason}`);
+        }
+      }
+      this.emitTaskUpdate(rootTask.id, "running", "Synthesizing results...");
+      const synthesis = await this.runSynthesis(goal, summaries);
+      this.emitter.emit({
+        type: "synthesis",
+        taskId: rootTask.id,
+        data: { content: synthesis }
+      });
+      this.emitTaskCompleted(rootTask.id, [], []);
+      this.emitter.emit({
+        type: "done",
+        data: { content: synthesis }
+      });
+    } catch (err) {
+      this.emitter.emit({
+        type: "error",
+        data: { message: String(err) }
+      });
+    } finally {
+      this.emitter.close();
+    }
+  }
+  // ── Planner ─────────────────────────────────────────────────────────────────
+  async runPlanner(goal) {
+    const { text } = await (0, import_ai2.generateText)({
+      model: gateway(this.config.plannerModel),
+      system: PLANNER_SYSTEM_PROMPT,
+      prompt: buildPlannerPrompt(goal),
+      maxOutputTokens: 2e3
+    });
+    const clean = text.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim();
+    const raw = JSON.parse(clean);
+    return WorkerPlanSchema.parse(raw);
+  }
+  // ── Worker ──────────────────────────────────────────────────────────────────
+  async runWorker(task, repoUrl, snapshotId) {
+    let sandbox = await createWorkerSandbox(repoUrl, snapshotId);
+    task.sandboxId = sandbox.id ?? "local";
+    this.emitTaskUpdate(task.id, "running", "Sandbox ready");
+    this.emitter.emit({
+      type: "task-updated",
+      taskId: task.id,
+      data: {
+        a2aCard: buildA2ACard(task),
+        status: "running",
+        statusText: "Sandbox ready"
+      }
+    });
+    const tools = createAgentTools(sandbox);
+    const findings = [];
+    const terminalLines = [];
+    const agent = new import_ai2.ToolLoopAgent({
+      model: gateway(this.config.workerModel),
+      tools,
+      stopWhen: (0, import_ai2.stepCountIs)(this.config.maxStepsPerAgent),
+      instructions: buildWorkerPrompt(task, findings),
+      onStepFinish: async ({ text, toolCalls, toolResults }) => {
+        if (text?.trim()) {
+          const lines = text.trim().split("\n").filter(Boolean);
+          for (const line of lines.slice(0, 3)) {
+            findings.push(line);
+            this.emitter.emit({
+              type: "finding",
+              taskId: task.id,
+              data: { text: line }
+            });
+          }
+        }
+        for (let i = 0; i < (toolCalls?.length ?? 0); i++) {
+          const call = toolCalls[i];
+          const result2 = toolResults?.[i];
+          const input = call.input ?? {};
+          let cmdLine = "";
+          if (call.toolName === "search") {
+            cmdLine = `$ grep -r "${input.pattern}" ${input.path ?? "."} ${input.fileGlob ? `--include="${input.fileGlob}"` : ""}`;
+          } else {
+            cmdLine = `$ ${input.command ?? ""}`;
+          }
+          terminalLines.push(cmdLine);
+          this.emitter.emit({
+            type: "terminal",
+            taskId: task.id,
+            data: { line: cmdLine }
+          });
+          if (result2?.result) {
+            const output = typeof result2.result === "string" ? result2.result : result2.result.output ?? JSON.stringify(result2.result);
+            const preview = String(output).split("\n").slice(0, 8).join("\n");
+            if (preview.trim()) {
+              this.emitter.emit({
+                type: "terminal",
+                taskId: task.id,
+                data: { line: preview, dim: true }
+              });
+            }
+          }
+        }
+        this.emitTaskUpdate(task.id, "running", `Step ${terminalLines.length} done`);
+      }
+    });
+    const result = await agent.stream({ prompt: task.goal });
+    for await (const _ of result.fullStream) {
+    }
+    const finalText = await result.text;
+    const artifacts = [];
+    try {
+      const newFiles = await collectNewFiles(sandbox, "/vercel/sandbox", ["ts", "tsx", "js", "json", "md"]);
+      for (const file of newFiles) {
+        const filename = file.path.split("/").pop() ?? file.path;
+        const artifact = {
+          filename,
+          content: file.content,
+          language: detectLanguage(filename)
+        };
+        artifacts.push(artifact);
+        this.emitter.emit({
+          type: "artifact",
+          taskId: task.id,
+          data: { artifact }
+        });
+      }
+    } catch {
+    }
+    this.emitTaskCompleted(task.id, findings, artifacts);
+    await stopSandbox(sandbox);
+    return finalText || findings.join("\n") || "No output";
+  }
+  // ── Synthesis ────────────────────────────────────────────────────────────────
+  async runSynthesis(goal, summaries) {
+    const { text } = await (0, import_ai2.generateText)({
+      model: gateway(this.config.plannerModel),
+      prompt: buildSynthesisPrompt(goal, summaries),
+      maxOutputTokens: 1500
+    });
+    return text;
+  }
+  // ── Helpers ──────────────────────────────────────────────────────────────────
+  makeTask(params) {
+    return {
+      id: uid(),
+      parentId: params.parentId,
+      role: params.role,
+      goal: params.goal,
+      icon: params.icon,
+      status: "pending",
+      statusText: "Waiting",
+      findings: [],
+      artifacts: [],
+      children: [],
+      sandboxId: null,
+      model: params.depth === 0 ? this.config.plannerModel : this.config.workerModel,
+      createdAt: Date.now(),
+      completedAt: null,
+      depth: params.depth
+    };
+  }
+  emitTaskCreated(task) {
+    this.emitter.emit({ type: "task-created", taskId: task.id, data: { task } });
+  }
+  emitTaskUpdate(id, status, statusText) {
+    this.emitter.emit({ type: "task-updated", taskId: id, data: { status, statusText } });
+  }
+  emitTaskCompleted(id, findings, artifacts) {
+    this.emitter.emit({
+      type: "task-completed",
+      taskId: id,
+      data: { findings, artifacts }
+    });
+  }
+};
+
+// ../../lib/vrlm/events.ts
+var VrlmEventEmitter = class {
+  handlers = [];
+  queue = [];
+  closed = false;
+  on(handler) {
+    this.handlers.push(handler);
+    for (const event of this.queue) {
+      handler(event);
+    }
+  }
+  emit(event) {
+    this.queue.push(event);
+    for (const handler of this.handlers) {
+      handler(event);
+    }
+  }
+  close() {
+    this.closed = true;
+  }
+  isClosed() {
+    return this.closed;
+  }
+};
+
+// ../../lib/vrlm/types.ts
+var DEFAULT_CONFIG = {
+  maxDepth: 3,
+  maxWorkers: 6,
+  maxTotalTasks: 15,
+  maxStepsPerAgent: 20,
+  plannerModel: "google/gemini-2.5-pro",
+  workerModel: "google/gemini-2.5-flash",
+  repoUrl: ""
+};
+
+// src/renderer.ts
+var import_picocolors = __toESM(require("picocolors"));
+var TerminalRenderer = class {
+  taskRoles = /* @__PURE__ */ new Map();
+  // taskId -> role
+  render(event) {
+    switch (event.type) {
+      case "task-created": {
+        const task = event.data.task;
+        this.taskRoles.set(task.id, task.role);
+        if (task.depth === 0) {
+          console.log("");
+          console.log(import_picocolors.default.bold(import_picocolors.default.white(`  ${task.icon ?? "\u{1F9E0}"} ${task.role}`)));
+          console.log(import_picocolors.default.dim(`  ${task.goal}`));
+        } else {
+          console.log(import_picocolors.default.dim(`  + `) + import_picocolors.default.cyan(`${task.icon ?? "\u{1F916}"} ${task.role}`));
+        }
+        break;
+      }
+      case "task-updated": {
+        const role = this.taskRoles.get(event.taskId ?? "") ?? "";
+        const status = event.data.statusText;
+        if (status && role) {
+          console.log(import_picocolors.default.dim(`  [${role}] `) + import_picocolors.default.white(status));
+        }
+        break;
+      }
+      case "terminal": {
+        const line = event.data.line;
+        const dim = event.data.dim;
+        if (dim) {
+          console.log(import_picocolors.default.dim(`    ${line}`));
+        } else {
+          console.log(import_picocolors.default.blue(`    ${line}`));
+        }
+        break;
+      }
+      case "finding": {
+        const text = event.data.text;
+        const role = this.taskRoles.get(event.taskId ?? "") ?? "";
+        console.log(import_picocolors.default.yellow(`  [${role}] `) + text);
+        break;
+      }
+      case "artifact": {
+        const artifact = event.data.artifact;
+        console.log(import_picocolors.default.green(`  + ${artifact.filename}`) + import_picocolors.default.dim(` (${artifact.language})`));
+        break;
+      }
+      case "collaboration": {
+        console.log(import_picocolors.default.magenta(`  ~ Collaboration: `) + (event.data.message ?? ""));
+        break;
+      }
+      case "task-completed": {
+        const role = this.taskRoles.get(event.taskId ?? "") ?? "";
+        console.log(import_picocolors.default.green(`  ok `) + role);
+        break;
+      }
+      case "synthesis": {
+        console.log("");
+        console.log(import_picocolors.default.bold(import_picocolors.default.white("Summary")));
+        console.log(import_picocolors.default.dim("------"));
+        console.log(event.data.content);
+        break;
+      }
+      case "done": {
+        console.log("");
+        console.log(import_picocolors.default.bold(import_picocolors.default.green("Done.")));
+        break;
+      }
+      case "error": {
+        console.error(import_picocolors.default.red("Error: ") + event.data.message);
+        break;
+      }
+    }
+  }
+};
+
+// src/commands/run.ts
+function loadSnapshotId(repoUrl) {
+  const snapshotFile = (0, import_path2.join)(process.cwd(), ".agentnetes", "snapshot.json");
+  if (!(0, import_fs2.existsSync)(snapshotFile)) return void 0;
+  try {
+    const data = JSON.parse((0, import_fs2.readFileSync)(snapshotFile, "utf-8"));
+    if (data.repoUrl === repoUrl) return data.snapshotId;
+  } catch {
+  }
+  return void 0;
+}
+async function run({ goal, repoUrl }) {
+  const snapshotId = loadSnapshotId(repoUrl);
+  console.log("");
+  console.log(import_picocolors2.default.bold(import_picocolors2.default.white("Agentnetes")));
+  console.log(import_picocolors2.default.dim("Zero to a self-organizing AI agency. On demand."));
+  console.log("");
+  console.log(import_picocolors2.default.dim("Repo:    ") + repoUrl);
+  console.log(import_picocolors2.default.dim("Goal:    ") + import_picocolors2.default.white(goal));
+  if (snapshotId) {
+    console.log(import_picocolors2.default.dim("Snapshot:") + import_picocolors2.default.green(" pre-warmed (fast start)"));
+  } else {
+    console.log(import_picocolors2.default.dim("Sandbox: ") + import_picocolors2.default.yellow('cloning from git (run "agentnetes snapshot create" to speed this up)'));
+  }
+  console.log("");
+  const emitter = new VrlmEventEmitter();
+  const renderer = new TerminalRenderer();
+  const config = {
+    ...DEFAULT_CONFIG,
+    repoUrl,
+    repoSnapshotId: snapshotId,
+    plannerModel: process.env.PLANNER_MODEL ?? DEFAULT_CONFIG.plannerModel,
+    workerModel: process.env.WORKER_MODEL ?? DEFAULT_CONFIG.workerModel
+  };
+  emitter.on((event) => renderer.render(event));
+  const runtime = new VrlmRuntime(emitter, config);
+  await runtime.run(goal);
+}
+
+// src/commands/snapshot.ts
+var import_child_process3 = require("child_process");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_picocolors3 = __toESM(require("picocolors"));
+var import_sandbox = require("@vercel/sandbox");
+async function snapshotCreate() {
+  let repoUrl;
+  try {
+    repoUrl = (0, import_child_process3.execSync)("git remote get-url origin", { encoding: "utf-8" }).trim();
+    if (repoUrl.startsWith("git@github.com:")) {
+      repoUrl = repoUrl.replace("git@github.com:", "https://github.com/").replace(".git", "");
+    }
+    if (repoUrl.endsWith(".git")) repoUrl = repoUrl.slice(0, -4);
+  } catch {
+    console.error('Error: not inside a git repository with a remote "origin".');
+    process.exit(1);
+    return;
+  }
+  console.log("");
+  console.log(import_picocolors3.default.bold("Creating sandbox snapshot"));
+  console.log(import_picocolors3.default.dim("Repo: ") + repoUrl);
+  console.log(import_picocolors3.default.dim("This takes 3-8 minutes depending on repo size."));
+  console.log("");
+  const sandbox = await import_sandbox.Sandbox.create({
+    source: { type: "git", url: repoUrl, depth: 1 },
+    timeout: 15 * 60 * 1e3
+  });
+  console.log(import_picocolors3.default.dim("Sandbox created. Installing dependencies..."));
+  const detectCmd = await sandbox.runCommand("bash", [
+    "-c",
+    "if [ -f pnpm-lock.yaml ]; then echo pnpm; elif [ -f yarn.lock ]; then echo yarn; else echo npm; fi"
+  ]);
+  const pkgManager = (await detectCmd.stdout()).trim();
+  const installCmd = pkgManager === "pnpm" ? "npm i -g pnpm && pnpm install --frozen-lockfile" : pkgManager === "yarn" ? "yarn install --frozen-lockfile" : "npm install";
+  console.log(import_picocolors3.default.dim(`Running ${pkgManager} install...`));
+  const install = await sandbox.runCommand("bash", ["-c", `${installCmd} 2>&1 | tail -10`]);
+  console.log(import_picocolors3.default.dim(await install.stdout()));
+  console.log(import_picocolors3.default.dim("Taking snapshot..."));
+  const snap = await sandbox.snapshot();
+  const dir = (0, import_path3.join)(process.cwd(), ".agentnetes");
+  if (!(0, import_fs3.existsSync)(dir)) (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  (0, import_fs3.writeFileSync)((0, import_path3.join)(dir, "snapshot.json"), JSON.stringify({
+    snapshotId: snap.snapshotId,
+    repoUrl,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2));
+  const gitignorePath = (0, import_path3.join)(process.cwd(), ".gitignore");
+  if ((0, import_fs3.existsSync)(gitignorePath)) {
+    const content = (0, import_fs3.readFileSync)(gitignorePath, "utf-8");
+    if (!content.includes(".agentnetes/")) {
+      (0, import_fs3.appendFileSync)(gitignorePath, "\n.agentnetes/\n");
+    }
+  }
+  console.log("");
+  console.log(import_picocolors3.default.bold(import_picocolors3.default.green("Snapshot created!")));
+  console.log(import_picocolors3.default.dim("ID: ") + snap.snapshotId);
+  console.log(import_picocolors3.default.dim("Saved to .agentnetes/snapshot.json"));
+  console.log("");
+  console.log("Future runs will use this snapshot automatically (near-instant start).");
+  await sandbox.stop();
+}
+async function snapshotList() {
+  console.log("");
+  console.log(import_picocolors3.default.bold("Available snapshots"));
+  console.log("");
+  const token = process.env.VERCEL_TOKEN;
+  if (!token) {
+    console.error(import_picocolors3.default.red("Error: VERCEL_TOKEN environment variable is not set."));
+    process.exit(1);
+    return;
+  }
+  const resp = await fetch("https://api.vercel.com/v1/sandbox/snapshots", {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!resp.ok) {
+    console.error(import_picocolors3.default.red(`Error fetching snapshots: ${resp.status} ${resp.statusText}`));
+    process.exit(1);
+    return;
+  }
+  const data = await resp.json();
+  for (const snap of data.snapshots) {
+    console.log(import_picocolors3.default.cyan(snap.id));
+    console.log(import_picocolors3.default.dim(`  Created: ${new Date(snap.createdAt).toLocaleString()}`));
+    console.log(import_picocolors3.default.dim(`  Size:    ${Math.round(snap.sizeBytes / 1024 / 1024)} MB`));
+    console.log("");
+  }
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+async function main() {
+  if (command === "run") {
+    const goal = args[1];
+    if (!goal) {
+      console.error('Usage: agentnetes run "your goal"');
+      process.exit(1);
+    }
+    let repoUrl;
+    try {
+      repoUrl = (0, import_child_process4.execSync)("git remote get-url origin", { encoding: "utf-8" }).trim();
+      if (repoUrl.startsWith("git@github.com:")) {
+        repoUrl = repoUrl.replace("git@github.com:", "https://github.com/").replace(".git", "");
+      }
+      if (repoUrl.endsWith(".git")) {
+        repoUrl = repoUrl.slice(0, -4);
+      }
+    } catch {
+      console.error('Error: not inside a git repository or no remote "origin" found.');
+      console.error("Run this command from the root of a git repository.");
+      process.exit(1);
+    }
+    await run({ goal, repoUrl });
+  } else if (command === "snapshot" && args[1] === "create") {
+    await snapshotCreate();
+  } else if (command === "snapshot" && args[1] === "list") {
+    await snapshotList();
+  } else {
+    console.log("agentnetes - zero to a self-organizing AI agency. On demand.");
+    console.log("");
+    console.log("Usage:");
+    console.log('  agentnetes run "goal"       Run agents on the current git repo');
+    console.log("  agentnetes snapshot create  Pre-warm a sandbox snapshot for faster runs");
+    console.log("  agentnetes snapshot list    List available snapshots");
+    console.log("");
+    console.log("Environment variables:");
+    console.log("  AI_GATEWAY_BASE_URL  Vercel AI Gateway endpoint");
+    console.log("  VERCEL_TOKEN         Vercel API token (for sandbox)");
+  }
+}
+main().catch((err) => {
+  console.error("Fatal:", err.message ?? err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "agentnetes",
+  "version": "0.1.0",
+  "description": "Zero to a self-organizing AI agency. On demand.",
+  "keywords": ["ai", "agents", "cli", "gemini", "vercel", "autonomous"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Shashikant86/agentnetes"
+  },
+  "homepage": "https://shashikant86.github.io/agentnetes",
+  "bin": {
+    "agentnetes": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@ai-sdk/gateway": "beta",
+    "@ai-sdk/google": "^3.0.52",
+    "@vercel/sandbox": "latest",
+    "ai": "beta",
+    "picocolors": "^1.1.1",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "tsup": "^8.0.0",
+    "tsx": "latest",
+    "typescript": "latest"
+  }
+}