@porchestra/cli 1.0.0 → 1.0.2

package/dist/index.js

@@ -0,0 +1,1666 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/config/project-tracker.ts
+var ProjectTracker;
+var init_project_tracker = __esm({
+  "src/core/config/project-tracker.ts"() {
+    "use strict";
+    ProjectTracker = class {
+      constructor(configManager) {
+        this.configManager = configManager;
+      }
+      async getTrackedProjects() {
+        const config = await this.configManager.get();
+        return config.trackedProjects || [];
+      }
+      async getTrackedAgents(projectId) {
+        const config = await this.configManager.get();
+        const project = config.trackedProjects?.find((p) => p.projectId === projectId);
+        return project?.agents || [];
+      }
+      async listTrackedAgents() {
+        const projects = await this.getTrackedProjects();
+        return projects.flatMap(
+          (project) => project.agents.map((agent) => ({ project, agent }))
+        );
+      }
+      async trackProject(project, agents) {
+        await this.configManager.update((config) => {
+          const existingIndex = config.trackedProjects.findIndex(
+            (p) => p.projectId === project.id
+          );
+          const trackedAgents = agents.map((agent) => ({
+            agentId: agent.id,
+            agentName: agent.name,
+            agentSlug: agent.slug,
+            folderPath: agent.folderPath,
+            selectedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          const trackedProject = {
+            projectId: project.id,
+            projectName: project.name,
+            projectSlug: project.slug,
+            selectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            agents: trackedAgents
+          };
+          const newProjects = [...config.trackedProjects];
+          if (existingIndex >= 0) {
+            newProjects[existingIndex] = trackedProject;
+          } else {
+            newProjects.push(trackedProject);
+          }
+          return { ...config, trackedProjects: newProjects };
+        });
+      }
+      async untrackProject(projectId) {
+        await this.configManager.update((config) => ({
+          ...config,
+          trackedProjects: config.trackedProjects.filter(
+            (p) => p.projectId !== projectId
+          )
+        }));
+      }
+      async untrackAgent(projectId, agentId) {
+        let removed = false;
+        await this.configManager.update((config) => {
+          const projectIndex = config.trackedProjects.findIndex(
+            (p) => p.projectId === projectId
+          );
+          if (projectIndex === -1) return config;
+          const project = config.trackedProjects[projectIndex];
+          const remainingAgents = project.agents.filter(
+            (agent) => agent.agentId !== agentId
+          );
+          if (remainingAgents.length === project.agents.length) {
+            return config;
+          }
+          removed = true;
+          const newProjects = [...config.trackedProjects];
+          if (remainingAgents.length === 0) {
+            newProjects.splice(projectIndex, 1);
+          } else {
+            newProjects[projectIndex] = { ...project, agents: remainingAgents };
+          }
+          return { ...config, trackedProjects: newProjects };
+        });
+        return removed;
+      }
+      async updateLastPulled(projectId, agentId, version) {
+        await this.configManager.update((config) => {
+          const projectIndex = config.trackedProjects.findIndex(
+            (p) => p.projectId === projectId
+          );
+          if (projectIndex === -1) return config;
+          const project = config.trackedProjects[projectIndex];
+          const agentIndex = project.agents.findIndex(
+            (a) => a.agentId === agentId
+          );
+          if (agentIndex === -1) return config;
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const newAgents = [...project.agents];
+          newAgents[agentIndex] = {
+            ...newAgents[agentIndex],
+            lastPulledAt: now,
+            lastPulledVersion: version
+          };
+          const newProjects = [...config.trackedProjects];
+          newProjects[projectIndex] = {
+            ...project,
+            agents: newAgents,
+            lastPulledAt: now
+          };
+          return { ...config, trackedProjects: newProjects };
+        });
+      }
+      async getSummary() {
+        const projects = await this.getTrackedProjects();
+        return {
+          projectCount: projects.length,
+          agentCount: projects.reduce((sum, p) => sum + p.agents.length, 0)
+        };
+      }
+    };
+  }
+});
+
+// src/utils/date.ts
+function formatDistanceToNow(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1e3);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffSecs < 60) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 30) return `${diffDays}d ago`;
+  return date.toISOString().split("T")[0];
+}
+function formatDate(dateStr) {
+  const date = new Date(dateStr);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+var init_date = __esm({
+  "src/utils/date.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/explore.ts
+var explore_exports = {};
+__export(explore_exports, {
+  createExploreCommand: () => createExploreCommand
+});
+import { Command as Command4 } from "commander";
+import { select, checkbox, confirm as confirm2, Separator } from "@inquirer/prompts";
+import pc4 from "picocolors";
+import ora from "ora";
+function createExploreCommand(configManager, apiClient) {
+  const projectTracker = new ProjectTracker(configManager);
+  return new Command4("explore").description("Explore and select projects/agents to track").option("-p, --project <id>", "Start with specific project").action(async (options) => {
+    const spinner = ora("Fetching projects...").start();
+    try {
+      const response = await apiClient.getProjectsBrief();
+      const projects = response.projects;
+      spinner.stop();
+      if (projects.length === 0) {
+        console.log(pc4.yellow("No projects found. Create one in the web app first."));
+        return;
+      }
+      let exploring = true;
+      while (exploring) {
+        const projectChoices = projects.map((p) => ({
+          name: `${p.name} ${pc4.gray(`(${p.agentCount} agents, last modified ${formatDate(p.lastModifiedAt)})`)}`,
+          value: p,
+          short: p.name
+        }));
+        let selectedProject;
+        if (options.project) {
+          selectedProject = projects.find((p) => p.id === options.project || p.slug === options.project);
+        } else {
+          const choices = [
+            ...projectChoices,
+            new Separator(),
+            { name: pc4.yellow("Done exploring"), value: "DONE" }
+          ];
+          selectedProject = await select({
+            message: "Select a project to explore:",
+            choices
+          });
+        }
+        if (selectedProject === "DONE") {
+          exploring = false;
+          break;
+        }
+        if (!selectedProject) {
+          console.log(pc4.red("Project not found"));
+          continue;
+        }
+        const agentSpinner = ora(`Fetching agents for ${selectedProject.name}...`).start();
+        const agentsResponse = await apiClient.getProjectAgents(selectedProject.id);
+        const agents = agentsResponse;
+        agentSpinner.succeed(`Found ${agents.agents.length} agents`);
+        console.log(pc4.bold(`
+\u{1F4C1} ${selectedProject.name}
+`));
+        agents.agents.forEach((agent) => {
+          const isPublished = agent.isPublished ? pc4.green("\u25CF") : pc4.gray("\u25CB");
+          const versionInfo = `${agent.version} ${pc4.gray(`(${agents.versionResolution.source})`)}`;
+          console.log(`  ${isPublished} ${pc4.cyan(agent.name)}`);
+          console.log(`     ${pc4.gray("Path:")} ${agent.folderPath}`);
+          console.log(`     ${pc4.gray("Version:")} ${versionInfo}`);
+          console.log(`     ${pc4.gray("Tools:")} ${agent.toolCount}`);
+          if (agents.versionResolution.source !== "PRODUCTION") {
+            console.log(`     ${pc4.yellow("\u26A0")} ${agents.versionResolution.note}`);
+          }
+          console.log();
+        });
+        const currentlyTracked = await projectTracker.getTrackedAgents(selectedProject.id);
+        const trackedIds = new Set(currentlyTracked.map((a) => a.agentId));
+        const selectedAgentIds = await checkbox({
+          message: "Select agents to track (space to toggle, enter to confirm):",
+          choices: agents.agents.map((agent) => ({
+            name: `${agent.name} ${pc4.gray(`(${agent.folderPath})`)}`,
+            value: agent.id,
+            checked: trackedIds.has(agent.id)
+          }))
+        });
+        if (selectedAgentIds.length > 0) {
+          const selectedAgents = agents.agents.filter((a) => selectedAgentIds.includes(a.id));
+          try {
+            await projectTracker.trackProject(selectedProject, selectedAgents);
+            console.log(pc4.green(`
+\u2713 Auto-saved: Tracking ${selectedAgents.length} agents from ${selectedProject.name}`));
+          } catch (error) {
+            console.error(pc4.red(`
+\u2717 Failed to save tracking: ${error.message}`));
+            throw error;
+          }
+        } else {
+          try {
+            await projectTracker.untrackProject(selectedProject.id);
+            console.log(pc4.yellow(`
+\u2713 Auto-saved: No longer tracking ${selectedProject.name}`));
+          } catch (error) {
+            console.error(pc4.red(`
+\u2717 Failed to untrack: ${error.message}`));
+            throw error;
+          }
+        }
+        if (!options.project) {
+          const continueExploring = await confirm2({
+            message: "Explore another project?",
+            default: true
+          });
+          if (!continueExploring) exploring = false;
+        } else {
+          exploring = false;
+        }
+      }
+      const summary = await projectTracker.getSummary();
+      console.log(pc4.bold("\n\u{1F4CA} Tracking Summary\n"));
+      console.log(`  Projects: ${summary.projectCount}`);
+      console.log(`  Agents:   ${summary.agentCount}`);
+      console.log(pc4.gray("\nRun `porchestra pull` to generate code for tracked agents\n"));
+    } catch (error) {
+      spinner.fail("Failed to fetch projects");
+      console.error(pc4.red(`
+\u2717 ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+var init_explore = __esm({
+  "src/commands/explore.ts"() {
+    "use strict";
+    init_project_tracker();
+    init_date();
+  }
+});
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+import pc9 from "picocolors";
+
+// src/core/config/config-manager.ts
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+import { z as z2 } from "zod";
+
+// src/core/config/config-schema.ts
+import { z } from "zod";
+var DateTimeStringSchema = z.string().optional();
+var TrackedAgentSchema = z.object({
+  agentId: z.string().uuid(),
+  agentName: z.string(),
+  agentSlug: z.string(),
+  folderPath: z.string(),
+  selectedAt: DateTimeStringSchema,
+  lastPulledAt: DateTimeStringSchema.optional(),
+  lastPulledVersion: z.string().optional()
+});
+var TrackedProjectSchema = z.object({
+  projectId: z.string().uuid(),
+  projectName: z.string(),
+  projectSlug: z.string(),
+  selectedAt: DateTimeStringSchema,
+  agents: z.array(TrackedAgentSchema),
+  lastPulledAt: DateTimeStringSchema.optional()
+});
+var CliConfigSchema = z.object({
+  auth: z.object({
+    token: z.string().optional(),
+    tokenId: z.string().uuid().optional(),
+    expiresAt: DateTimeStringSchema.optional(),
+    deviceName: z.string().optional()
+  }).optional(),
+  api: z.object({
+    baseUrl: z.string().url().default("https://api.porchestra.io/v1"),
+    skipTlsVerify: z.boolean().default(false)
+  }).default({}),
+  trackedProjects: z.array(TrackedProjectSchema).default([]),
+  output: z.object({
+    baseDir: z.string().default("./src/agents"),
+    createIndexFiles: z.boolean().default(true)
+  }).default({}),
+  cli: z.object({
+    lastLoginAt: DateTimeStringSchema.optional(),
+    lastVersionCheck: DateTimeStringSchema.optional(),
+    latestKnownVersion: z.string().optional()
+  }).optional(),
+  version: z.literal("1.0.0")
+});
+
+// src/core/config/config-manager.ts
+var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".porchestra");
+var CONFIG_FILE = "config.json";
+var ConfigManager = class {
+  configPath;
+  config = null;
+  constructor() {
+    const configDir = process.env.PORCHESTRA_CONFIG_DIR || DEFAULT_CONFIG_DIR;
+    this.configPath = path.join(configDir, CONFIG_FILE);
+  }
+  async load() {
+    try {
+      const data = await fs.readFile(this.configPath, "utf-8");
+      const parsed = JSON.parse(data);
+      const validated = CliConfigSchema.parse(parsed);
+      this.config = validated;
+      return validated;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        const defaultConfig = { version: "1.0.0" };
+        this.config = CliConfigSchema.parse(defaultConfig);
+        return this.config;
+      }
+      if (error instanceof z2.ZodError) {
+        console.error("\u274C Config validation failed:");
+        error.errors.forEach((err) => {
+          console.error(`  - ${err.path.join(".")}: ${err.message}`);
+        });
+        throw new Error(`Invalid config file at ${this.configPath}. Please run 'porchestra config reset' to fix.`);
+      }
+      throw error;
+    }
+  }
+  async save(config) {
+    try {
+      const validated = CliConfigSchema.parse(config);
+      const configDir = path.dirname(this.configPath);
+      await fs.mkdir(configDir, { recursive: true });
+      const tempPath = `${this.configPath}.tmp`;
+      await fs.writeFile(
+        tempPath,
+        JSON.stringify(validated, null, 2),
+        "utf-8"
+      );
+      await fs.rename(tempPath, this.configPath);
+      this.config = validated;
+    } catch (error) {
+      if (error instanceof z2.ZodError) {
+        console.error("\u274C Config validation failed on save:");
+        error.errors.forEach((err) => {
+          console.error(`  - ${err.path.join(".")}: ${err.message}`);
+        });
+        throw new Error("Failed to save config: validation error");
+      }
+      throw error;
+    }
+  }
+  async get() {
+    if (!this.config) {
+      return this.load();
+    }
+    return this.config;
+  }
+  async update(updater) {
+    const config = await this.get();
+    const updated = updater({ ...config });
+    await this.save(updated);
+  }
+  async clear() {
+    try {
+      await fs.unlink(this.configPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    this.config = null;
+  }
+  getConfigPath() {
+    return this.configPath;
+  }
+};
+
+// src/utils/errors.ts
+var PorchestraError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "PorchestraError";
+  }
+};
+var AuthenticationError = class extends PorchestraError {
+  constructor(message, retryable = false) {
+    super(message, "AUTH_ERROR");
+    this.retryable = retryable;
+    this.name = "AuthenticationError";
+  }
+};
+var NetworkError = class extends PorchestraError {
+  constructor(message, statusCode, retryable = true) {
+    super(message, "NETWORK_ERROR");
+    this.statusCode = statusCode;
+    this.retryable = retryable;
+    this.name = "NetworkError";
+  }
+};
+
+// src/core/auth/auth-service.ts
+import got from "got";
+import os2 from "os";
+var AuthService = class {
+  configManager;
+  constructor(configManager) {
+    this.configManager = configManager;
+  }
+  async login(credentials) {
+    const config = await this.configManager.get();
+    const baseUrl = credentials.apiUrl || config.api?.baseUrl || "https://api.porchestra.io/v1";
+    const deviceInfo = {
+      os: os2.platform(),
+      version: os2.release(),
+      cliVersion: "1.0.0"
+    };
+    const deviceName = credentials.deviceName || `${os2.hostname()} - ${deviceInfo.os}`;
+    try {
+      const response = await got.post(`${baseUrl}/cli/login`, {
+        json: {
+          email: credentials.email,
+          password: credentials.password,
+          deviceName,
+          deviceInfo
+        },
+        headers: {
+          "Content-Type": "application/json"
+        },
+        https: {
+          rejectUnauthorized: !credentials.skipTlsVerify
+        }
+      }).json();
+      return response.data;
+    } catch (error) {
+      if (error.response?.statusCode) {
+        if (error.response.statusCode === 401) {
+          throw new AuthenticationError("Invalid email or password");
+        }
+        throw new AuthenticationError(`Login failed: ${error.message}`);
+      }
+      if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ETIMEDOUT") {
+        throw new NetworkError(`Network error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  async refreshToken(tokenId, currentToken) {
+    const config = await this.configManager.get();
+    const baseUrl = config.api?.baseUrl || "https://api.porchestra.io/v1";
+    try {
+      const response = await got.post(`${baseUrl}/cli/token/refresh`, {
+        json: {
+          tokenId,
+          currentToken
+        },
+        headers: {
+          "Authorization": `Bearer ${currentToken}`,
+          "Content-Type": "application/json"
+        }
+      }).json();
+      return response.data;
+    } catch (error) {
+      if (error.response?.statusCode === 401) {
+        throw new AuthenticationError("Token refresh failed. Please login again.");
+      }
+      throw error;
+    }
+  }
+  async revokeToken(token, revokeAll = false) {
+    const config = await this.configManager.get();
+    const baseUrl = config.api?.baseUrl || "https://api.porchestra.io/v1";
+    try {
+      const response = await got.delete(`${baseUrl}/cli/token`, {
+        json: {
+          revokeAll
+        },
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      }).json();
+      return response.data;
+    } catch (error) {
+      if (error.response?.statusCode === 401) {
+        throw new AuthenticationError("Token already revoked or invalid");
+      }
+      throw error;
+    }
+  }
+  async getCurrentUser(token) {
+    const config = await this.configManager.get();
+    const baseUrl = config.api?.baseUrl || "https://api.porchestra.io/v1";
+    try {
+      const response = await got.get(`${baseUrl}/auth/me`, {
+        headers: {
+          "Authorization": `Bearer ${token}`
+        }
+      }).json();
+      return response.data;
+    } catch (error) {
+      if (error.response?.statusCode === 401) {
+        throw new AuthenticationError("Token is invalid or expired");
+      }
+      throw error;
+    }
+  }
+  async checkAndRefreshTokenIfNeeded() {
+    const config = await this.configManager.get();
+    if (!config.auth?.token || !config.auth?.tokenId || !config.auth?.expiresAt) {
+      return false;
+    }
+    const expiresAt = new Date(config.auth.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    const sevenDaysFromNow = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1e3);
+    if (expiresAt < sevenDaysFromNow) {
+      try {
+        const refreshed = await this.refreshToken(
+          config.auth.tokenId,
+          config.auth.token
+        );
+        await this.configManager.update((cfg) => ({
+          ...cfg,
+          auth: {
+            ...cfg.auth,
+            token: refreshed.token,
+            expiresAt: refreshed.expiresAt
+          }
+        }));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/core/auth/token-manager.ts
+var TokenManager = class {
+  constructor(configManager) {
+    this.configManager = configManager;
+  }
+  async getToken() {
+    const config = await this.configManager.get();
+    return config.auth?.token;
+  }
+  async getTokenId() {
+    const config = await this.configManager.get();
+    return config.auth?.tokenId;
+  }
+  async getExpiresAt() {
+    const config = await this.configManager.get();
+    return config.auth?.expiresAt;
+  }
+  async isAuthenticated() {
+    const token = await this.getToken();
+    if (!token) return false;
+    const expiresAt = await this.getExpiresAt();
+    if (!expiresAt) return false;
+    const expiryDate = new Date(expiresAt);
+    return expiryDate > /* @__PURE__ */ new Date();
+  }
+  async getDaysUntilExpiry() {
+    const expiresAt = await this.getExpiresAt();
+    if (!expiresAt) return null;
+    const expiryDate = new Date(expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = expiryDate.getTime() - now.getTime();
+    return Math.ceil(diffMs / (1e3 * 60 * 60 * 24));
+  }
+  async isExpiringSoon(days = 7) {
+    const daysUntilExpiry = await this.getDaysUntilExpiry();
+    if (daysUntilExpiry === null) return false;
+    return daysUntilExpiry <= days;
+  }
+};
+
+// src/core/api/client.ts
+import got2 from "got";
+var MAX_RETRIES = 3;
+var RETRY_DELAY = 1e3;
+var ApiClient = class {
+  configManager;
+  constructor(configManager) {
+    this.configManager = configManager;
+  }
+  async getBaseUrl() {
+    const config = await this.configManager.get();
+    return config.api?.baseUrl || "https://api.porchestra.io/v1";
+  }
+  async getToken() {
+    const config = await this.configManager.get();
+    return config.auth?.token;
+  }
+  async requestWithRetry(url, options, attempt = 1) {
+    try {
+      const token = await this.getToken();
+      const headers = {
+        "Content-Type": "application/json",
+        ...token && { Authorization: `Bearer ${token}` },
+        ...options.headers || {}
+      };
+      const response = await got2(url, {
+        method: options.method,
+        headers,
+        retry: { limit: 0 }
+      }).json();
+      return response.data;
+    } catch (error) {
+      if (error.response?.statusCode === 401) {
+        throw new AuthenticationError("Authentication failed. Please login again.");
+      }
+      const isRetryable = error.code === "ECONNRESET" || error.code === "ETIMEDOUT" || error.code === "ENOTFOUND" || error.response?.statusCode && error.response.statusCode >= 500;
+      if (isRetryable && attempt < MAX_RETRIES) {
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY * attempt));
+        return this.requestWithRetry(url, options, attempt + 1);
+      }
+      throw new NetworkError(
+        `API request failed: ${error.message}`,
+        error.response?.statusCode,
+        isRetryable
+      );
+    }
+  }
+  async getProjectsBrief() {
+    const baseUrl = await this.getBaseUrl();
+    return this.requestWithRetry(
+      `${baseUrl}/projects/brief`,
+      { method: "GET" }
+    );
+  }
+  async getProjectAgents(projectId, environment) {
+    const baseUrl = await this.getBaseUrl();
+    const query = environment ? `?environment=${environment}` : "";
+    return this.requestWithRetry(
+      `${baseUrl}/projects/${projectId}/agents${query}`,
+      { method: "GET" }
+    );
+  }
+  async getAgentTools(projectId, agentId, environment) {
+    const baseUrl = await this.getBaseUrl();
+    const query = environment ? `?environment=${environment}` : "";
+    return this.requestWithRetry(
+      `${baseUrl}/projects/${projectId}/agents/${agentId}/tools${query}`,
+      { method: "GET" }
+    );
+  }
+  async getCurrentUser(token) {
+    const baseUrl = await this.getBaseUrl();
+    return this.requestWithRetry(
+      `${baseUrl}/auth/me`,
+      {
+        method: "GET",
+        headers: { Authorization: `Bearer ${token}` }
+      }
+    );
+  }
+  async getCliConfig() {
+    const baseUrl = await this.getBaseUrl();
+    return this.requestWithRetry(
+      `${baseUrl}/cli/config`,
+      { method: "GET" }
+    );
+  }
+};
+
+// src/core/generators/code-generator.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+import Handlebars from "handlebars";
+
+// src/utils/path-utils.ts
+import path2 from "path";
+function normalizeFolderPath(folderPath) {
+  let normalized = folderPath.replace(/^\//, "");
+  normalized = normalized.replace(/\/+/g, "/");
+  normalized = normalized.split("/").map((segment) => sanitizePathSegment(segment)).join("/");
+  normalized = normalized.replace(/\/$/, "");
+  return normalized;
+}
+function sanitizePathSegment(segment) {
+  return segment.replace(/[^a-zA-Z0-9-_]/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+}
+function calculateAgentOutputPath(baseDir, folderPath, agentName, filename) {
+  const normalizedFolder = normalizeFolderPath(folderPath);
+  const normalizedAgent = sanitizePathSegment(agentName);
+  const fullPath = path2.join(baseDir, normalizedFolder, normalizedAgent);
+  return filename ? path2.join(fullPath, filename) : fullPath;
+}
+
+// src/core/generators/code-generator.ts
+Handlebars.registerHelper("pascalCase", function(str) {
+  return str.replace(/[-_\s](.)/g, (_, char) => char.toUpperCase()).replace(/^(.)/, (_, char) => char.toUpperCase());
+});
+Handlebars.registerHelper("camelCase", function(str) {
+  return str.replace(/[-_\s](.)/g, (_, char) => char.toUpperCase()).replace(/^(.)/, (_, char) => char.toLowerCase());
+});
+Handlebars.registerHelper("zodType", function(schema) {
+  return jsonSchemaToZodType(schema);
+});
+Handlebars.registerHelper("json", function(value) {
+  return JSON.stringify(value ?? {}, null, 2);
+});
+function normalizeSchemaContent(content) {
+  if (typeof content === "string") {
+    try {
+      return JSON.parse(content);
+    } catch {
+      return void 0;
+    }
+  }
+  return content;
+}
+function buildVariableJsonSchemaFromDefinitions(defs) {
+  const schema = {
+    type: "object",
+    properties: {},
+    required: []
+  };
+  const ensureObjectSchema = (target, key) => {
+    if (!target.properties[key]) {
+      target.properties[key] = { type: "object", properties: {}, required: [] };
+    }
+    return target.properties[key];
+  };
+  const toJsonSchema = (def) => {
+    const type = def?.type;
+    if (type === "enum") {
+      return {
+        type: "string",
+        enum: def?.validation?.options ?? []
+      };
+    }
+    if (type === "string" || type === "number" || type === "boolean") {
+      return { type };
+    }
+    if (type === "array") {
+      return { type: "array", items: {} };
+    }
+    if (type === "object") {
+      return { type: "object", properties: {} };
+    }
+    return {};
+  };
+  for (const def of defs) {
+    if (!def?.path || typeof def.path !== "string") continue;
+    const pathParts = def.path.split(".").filter(Boolean);
+    if (pathParts.length === 0) continue;
+    let curr = schema;
+    for (let i = 0; i < pathParts.length; i++) {
+      const key = pathParts[i];
+      const isLeaf = i === pathParts.length - 1;
+      if (isLeaf) {
+        curr.properties[key] = toJsonSchema(def);
+        if (def?.validation?.required !== false) {
+          curr.required.push(key);
+        }
+      } else {
+        curr = ensureObjectSchema(curr, key);
+      }
+    }
+  }
+  if (schema.required.length === 0) delete schema.required;
+  return schema;
+}
+function jsonSchemaToZodType(schema) {
+  if (!schema) return "z.any()";
+  switch (schema.type) {
+    case "string": {
+      let zod = "z.string()";
+      if (schema.minLength) zod += `.min(${schema.minLength})`;
+      if (schema.maxLength) zod += `.max(${schema.maxLength})`;
+      if (schema.pattern) zod += `.regex(/${schema.pattern}/)`;
+      if (schema.enum) zod = `z.enum([${schema.enum.map((e) => `'${e}'`).join(", ")}])`;
+      if (schema.nullable) zod += ".nullable()";
+      return zod;
+    }
+    case "number":
+    case "integer": {
+      let zod = schema.type === "integer" ? "z.number().int()" : "z.number()";
+      if (schema.minimum !== void 0) zod += `.min(${schema.minimum})`;
+      if (schema.maximum !== void 0) zod += `.max(${schema.maximum})`;
+      if (schema.nullable) zod += ".nullable()";
+      return zod;
+    }
+    case "boolean": {
+      let zod = "z.boolean()";
+      if (schema.nullable) zod += ".nullable()";
+      return zod;
+    }
+    case "array": {
+      const itemType = jsonSchemaToZodType(schema.items);
+      let zod = `z.array(${itemType})`;
+      if (schema.minItems) zod += `.min(${schema.minItems})`;
+      if (schema.maxItems) zod += `.max(${schema.maxItems})`;
+      if (schema.nullable) zod += ".nullable()";
+      return zod;
+    }
+    case "object": {
+      if (!schema.properties) return "z.record(z.any())";
+      const required = new Set(schema.required || []);
+      const props = Object.entries(schema.properties).map(([key, prop]) => {
+        const propType = jsonSchemaToZodType(prop);
+        const isRequired = required.has(key);
+        const formattedKey = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+        return `  ${formattedKey}: ${isRequired ? propType : `${propType}.optional()`}`;
+      });
+      let zod = `z.object({
+${props.join(",\n")}
+})`;
+      if (schema.additionalProperties === false) zod += ".strict()";
+      if (schema.nullable) zod += ".nullable()";
+      return zod;
+    }
+    default:
+      return "z.any()";
+  }
+}
+var CodeGenerator = class {
+  schemasTemplate;
+  toolsTemplate;
+  indexTemplate;
+  constructor() {
+    this.schemasTemplate = Handlebars.compile(schemasTemplateSource);
+    this.toolsTemplate = Handlebars.compile(toolsTemplateSource);
+    this.indexTemplate = Handlebars.compile(indexTemplateSource);
+  }
+  async generate(options) {
+    const { agent, tools, components, outputDir } = options;
+    await fs2.mkdir(outputDir, { recursive: true });
+    const responseJsonSchema = components?.responseSchema?.content || {};
+    const rawVariableSchema = normalizeSchemaContent(components?.variableSchema?.content);
+    const resolvedVariableSchema = Array.isArray(rawVariableSchema) ? buildVariableJsonSchemaFromDefinitions(rawVariableSchema) : rawVariableSchema || null;
+    const templateData = {
+      agentName: agent?.name || "Unknown Agent",
+      version: agent?.version || "unknown",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tools: (tools || []).filter((t) => t && !t.isBuiltin && typeof t.name === "string" && t.name.length > 0).map((t) => ({
+        name: t.name,
+        description: t.description || "",
+        parameters: t.parameters || {},
+        returns: t.returns ?? null,
+        isBuiltin: t.isBuiltin,
+        builtinType: t.builtinType
+      })),
+      variableSchema: resolvedVariableSchema,
+      inputSchema: components?.inputSchema?.content || null,
+      responseSchema: components?.responseSchema?.content || null,
+      responseJsonSchema
+    };
+    const astPath = path3.join(outputDir, "ast.json");
+    const astContent = JSON.stringify(components?.ast?.content ?? {}, null, 2);
+    await fs2.writeFile(astPath, astContent, "utf-8");
+    const configPath = path3.join(outputDir, "config.ts");
+    const configContent = `/**
+ * Auto-generated model config for ${templateData.agentName}
+ * Generated: ${templateData.generatedAt}
+ * Version: ${templateData.version}
+ * DO NOT MODIFY - This file is auto-generated by Porchestra CLI
+ */
+
+export const ModelConfig = ${JSON.stringify(components?.modelConfig?.content ?? {}, null, 2)} as const;
+`;
+    await fs2.writeFile(configPath, configContent, "utf-8");
+    const schemasPath = path3.join(outputDir, "schemas.ts");
+    const schemasContent = this.schemasTemplate(templateData);
+    await fs2.writeFile(schemasPath, schemasContent, "utf-8");
+    const toolsPath = path3.join(outputDir, "tools.ts");
+    const toolsContent = this.toolsTemplate(templateData);
+    await fs2.writeFile(toolsPath, toolsContent, "utf-8");
+    const indexPath = path3.join(outputDir, "index.ts");
+    const indexContent = this.indexTemplate(templateData);
+    await fs2.writeFile(indexPath, indexContent, "utf-8");
+  }
+  calculateOutputPath(baseDir, folderPath, agentName) {
+    return calculateAgentOutputPath(baseDir, folderPath, agentName);
+  }
+};
+var schemasTemplateSource = `/**
+ * Auto-generated Zod schemas for {{agentName}}
+ * Generated: {{generatedAt}}
+ * Version: {{version}}
+ * DO NOT MODIFY - This file is auto-generated by Porchestra CLI
+ */
+
+import { z } from 'zod';
+
+// 1. System Prompt Variables
+export const VariableSchema = {{{zodType variableSchema}}};
+export type AgentVariables = z.infer<typeof VariableSchema>;
+
+// 2. User Input
+export const InputSchema = {{{zodType inputSchema}}};
+export type AgentInput = z.infer<typeof InputSchema>;
+
+// 3. Model Response
+export const ResponseSchema = {{{zodType responseSchema}}};
+export type AgentResponse = z.infer<typeof ResponseSchema>;
+
+// 4. Raw JSON Schema (for LLM Provider 'response_format')
+export const ResponseJsonSchema = {{{json responseJsonSchema}}} as const;
+`;
+var toolsTemplateSource = `/**
+ * Auto-generated tools for {{agentName}}
+ * Generated: {{generatedAt}}
+ * Version: {{version}}
+ * DO NOT MODIFY - This file is auto-generated by Porchestra CLI
+ */
+
+import { z } from 'zod';
+
+{{#each tools}}
+// Schema for {{name}}
+export const {{pascalCase name}}Params = {{{zodType parameters}}};
+export type {{pascalCase name}}ParamsType = z.infer<typeof {{pascalCase name}}Params>;
+
+{{/each}}
+// The Interface the user MUST implement
+export interface ToolImplementation {
+{{#each tools}}
+  {{camelCase name}}: (args: {{pascalCase name}}ParamsType) => Promise<unknown>;
+{{/each}}
+}
+
+// Raw Tool Definitions for provider SDKs
+export const ToolDefinitions = [
+{{#each tools}}
+  {
+    name: '{{name}}',
+    description: {{{json description}}},
+    parameters: {{{json parameters}}},
+  },
+{{/each}}
+] as const;
+
+// Dispatcher with validation
+export async function dispatch(
+  name: string,
+  args: unknown,
+  impl: ToolImplementation
+): Promise<unknown> {
+  switch (name) {
+    {{#each tools}}
+    case '{{name}}':
+      return await impl.{{camelCase name}}({{pascalCase name}}Params.parse(args));
+    {{/each}}
+    default:
+      throw new Error(\`Unknown tool: \${name}\`);
+  }
+}
+`;
+var indexTemplateSource = `/**
+ * Auto-generated Agent class for {{agentName}}
+ * Generated: {{generatedAt}}
+ * Version: {{version}}
+ * DO NOT MODIFY - This file is auto-generated by Porchestra CLI
+ */
+
+import { PorchestraRuntime } from '@porchestra/core';
+import rawAst from './ast.json';
+import { ModelConfig } from './config.js';
+import * as Schemas from './schemas.js';
+import * as Tools from './tools.js';
+
+export class {{pascalCase agentName}}Agent {
+  /**
+   * @param tools - The implementation of the tool logic. Required if the agent uses tools.
+   */
+  constructor(private readonly tools?: Tools.ToolImplementation) {}
+
+  /**
+   * Renders the System Prompt.
+   * Throws ZodError if variables are invalid.
+   */
+  public renderPrompt(variables: Schemas.AgentVariables): string {
+    const safeVars = Schemas.VariableSchema.parse(variables);
+    return PorchestraRuntime.render(rawAst as any, safeVars);
+  }
+
+  /**
+   * Routes an LLM Tool Call to your implementation.
+   * Validates arguments automatically.
+   */
+  public async handleTool(name: string, args: unknown): Promise<unknown> {
+    if (!this.tools) {
+      throw new Error('No tool implementation provided to Agent constructor.');
+    }
+    return Tools.dispatch(name, args, this.tools);
+  }
+
+  /** Validates User Input (e.g. from API Request) */
+  public static validateInput(data: unknown): Schemas.AgentInput {
+    return Schemas.InputSchema.parse(data);
+  }
+
+  /** Validates LLM Output (Post-generation check) */
+  public static validateResponse(data: unknown): Schemas.AgentResponse {
+    return Schemas.ResponseSchema.parse(data);
+  }
+
+  /** Get Provider Configuration */
+  public static get config() {
+    return ModelConfig;
+  }
+
+  /** Get Tool Definitions for the LLM Provider */
+  public static get toolDefinitions() {
+    return Tools.ToolDefinitions;
+  }
+
+  /** Get JSON Schema for Structured Outputs */
+  public static get responseFormat() {
+    return Schemas.ResponseJsonSchema;
+  }
+}
+`;
+
+// src/commands/login.ts
+import { Command } from "commander";
+import pc from "picocolors";
+import { input, password } from "@inquirer/prompts";
+function createLoginCommand(configManager, authService) {
+  return new Command("login").description("Authenticate with your Porchestra account").option("--api-url <url>", "Override API URL").option("--skip-tls-verify", "Skip TLS certificate verification (insecure)").action(async (options) => {
+    console.log(pc.bold("\n  \u{1F510} Porchestra CLI Login\n"));
+    const apiUrl = options.apiUrl || process.env.PORCHESTRA_API_URL;
+    if (options.skipTlsVerify) {
+      console.log(pc.yellow("\n  \u26A0\uFE0F  WARNING: TLS verification disabled. Not recommended for production.\n"));
+    }
+    const email = await input({
+      message: "  Email:",
+      validate: (value) => value.includes("@") || "Please enter a valid email"
+    });
+    const pwd = await password({
+      message: "  Password:",
+      mask: "*"
+    });
+    try {
+      const result = await authService.login({
+        email,
+        password: pwd,
+        apiUrl,
+        skipTlsVerify: options.skipTlsVerify
+      });
+      console.log(pc.yellow("\n  [DEBUG] Raw API response:"));
+      console.log(pc.yellow(`    token: ${result.token?.substring(0, 20)}...`));
+      console.log(pc.yellow(`    tokenId: ${result.tokenId}`));
+      console.log(pc.yellow(`    expiresAt: ${result.expiresAt}`));
+      console.log(pc.yellow(`    issuedAt: ${result.issuedAt}`));
+      console.log(pc.yellow(`    deviceName: ${result.deviceName}`));
+      try {
+        await configManager.update((cfg) => ({
+          ...cfg,
+          auth: {
+            token: result.token,
+            tokenId: result.tokenId,
+            expiresAt: result.expiresAt,
+            deviceName: result.deviceName
+          },
+          api: {
+            baseUrl: apiUrl || cfg.api?.baseUrl || "https://api.porchestra.io/v1",
+            skipTlsVerify: options.skipTlsVerify || false
+          },
+          cli: {
+            ...cfg.cli,
+            lastLoginAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }));
+        const savedConfig = await configManager.get();
+        console.log(pc.yellow("\n  [DEBUG] Saved config auth:"));
+        console.log(pc.yellow(`    ${JSON.stringify(savedConfig.auth, null, 2)}`));
+      } catch (saveError) {
+        console.error(pc.red("\n  [DEBUG] Save error:"), saveError);
+        throw saveError;
+      }
+      const expiresAt = new Date(result.expiresAt);
+      const daysUntilExpiry = Math.ceil((expiresAt.getTime() - Date.now()) / (1e3 * 60 * 60 * 24));
+      console.log(pc.green(`
+  \u2713 Login successful
+        `));
+      console.log(pc.gray(`  Token expires in ${daysUntilExpiry} days (${result.expiresAt})`));
+      console.log(pc.gray(`  Device: ${result.deviceName}`));
+      if (apiUrl) {
+        console.log(pc.gray(`  API: ${apiUrl}`));
+      }
+      console.log(pc.gray(`  Auto-refresh: 7 days before expiry`));
+      console.log();
+    } catch (error) {
+      console.error(pc.red(`
+  \u2717 Login failed: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+import pc2 from "picocolors";
+import { confirm } from "@inquirer/prompts";
+function createLogoutCommand(configManager, authService) {
+  return new Command2("logout").description("Logout and revoke CLI token").option("--all", "Revoke all device tokens (logout everywhere)").action(async (options) => {
+    const config = await configManager.get();
+    if (!config.auth?.token) {
+      console.log(pc2.yellow("Not currently logged in"));
+      return;
+    }
+    if (options.all) {
+      const confirmed = await confirm({
+        message: "This will revoke ALL your CLI tokens on ALL devices. Continue?",
+        default: false
+      });
+      if (!confirmed) return;
+    }
+    try {
+      await authService.revokeToken(config.auth.token, options.all);
+      await configManager.clear();
+      if (options.all) {
+        console.log(pc2.green("\u2713 Revoked all tokens and logged out all devices"));
+      } else {
+        console.log(pc2.green("\u2713 Logged out successfully"));
+      }
+    } catch (error) {
+      await configManager.clear();
+      console.log(pc2.yellow("\u2713 Cleared local credentials (server revoke may have failed)"));
+    }
+  });
+}
+
+// src/commands/whoami.ts
+init_project_tracker();
+import { Command as Command3 } from "commander";
+import pc3 from "picocolors";
+function createWhoamiCommand(configManager, authService) {
+  const projectTracker = new ProjectTracker(configManager);
+  return new Command3("whoami").description("Show current user and token information").action(async () => {
+    const config = await configManager.get();
+    if (!config.auth?.token) {
+      console.log(pc3.yellow("Not logged in. Run `porchestra login`"));
+      return;
+    }
+    try {
+      const userInfo = await authService.getCurrentUser(config.auth.token);
+      const expiresAt = new Date(config.auth.expiresAt);
+      const isExpiringSoon = expiresAt.getTime() - Date.now() < 7 * 24 * 60 * 60 * 1e3;
+      console.log(pc3.bold("\n\u{1F464} User Information\n"));
+      console.log(`  Email:    ${pc3.cyan(userInfo.email)}`);
+      console.log(`  Name:     ${userInfo.name || "N/A"}`);
+      console.log(pc3.bold("\n\u{1F511} Token Information\n"));
+      console.log(`  Device:   ${config.auth.deviceName || "N/A"}`);
+      console.log(`  Expires:  ${isExpiringSoon ? pc3.yellow(expiresAt.toISOString()) : pc3.green(expiresAt.toISOString())}`);
+      if (isExpiringSoon) {
+        console.log(pc3.yellow("  \u26A0\uFE0F  Expires within 7 days - will auto-refresh"));
+      }
+      if (config.api?.baseUrl !== "https://api.porchestra.io/v1") {
+        console.log(pc3.bold("\n\u{1F517} API Configuration\n"));
+        console.log(`  URL:      ${config.api?.baseUrl}`);
+      }
+      const summary = await projectTracker.getSummary();
+      console.log(pc3.bold("\n\u{1F4C1} Tracked Projects\n"));
+      console.log(`  Projects: ${summary.projectCount}`);
+      console.log(`  Agents:   ${summary.agentCount}`);
+    } catch (error) {
+      console.log(pc3.red("Failed to fetch user info. Token may be invalid."));
+      console.log(pc3.gray("Run `porchestra login` to re-authenticate."));
+    }
+  });
+}
+
+// src/index.ts
+init_explore();
+
+// src/commands/pull.ts
+init_project_tracker();
+import { Command as Command5 } from "commander";
+import path4 from "path";
+import pc5 from "picocolors";
+import ora2 from "ora";
+function createPullCommand(configManager, apiClient, codeGenerator) {
+  const projectTracker = new ProjectTracker(configManager);
+  return new Command5("pull").description("Generate tool code for tracked agents").option("-p, --project <id>", "Pull specific project only").option("-a, --agent <id>", "Pull specific agent only").option("-e, --env <environment>", "Target environment (production|staging|development)").option("-o, --output <path>", "Override output directory").option("--force", "Overwrite implementation files (WARNING: may lose code)").action(async (options) => {
+    const config = await configManager.get();
+    if (!config.auth?.token) {
+      console.log(pc5.red("Not logged in. Run `porchestra login` first."));
+      process.exit(1);
+    }
+    let trackedProjects = await projectTracker.getTrackedProjects();
+    if (trackedProjects.length === 0) {
+      console.log(pc5.yellow("\n\u26A0 No projects selected for tracking.\n"));
+      console.log(pc5.gray("Starting project explorer...\n"));
+      const { createExploreCommand: createExploreCommand2 } = await Promise.resolve().then(() => (init_explore(), explore_exports));
+      const exploreCmd = createExploreCommand2(configManager, apiClient);
+      await exploreCmd.parseAsync(["node", "script", "explore"]);
+      trackedProjects = await projectTracker.getTrackedProjects();
+      if (trackedProjects.length === 0) {
+        console.log(pc5.red("\n\u274C No projects selected. Run `porchestra explore` to select projects."));
+        process.exit(1);
+      }
+    }
+    if (options.project) {
+      trackedProjects = trackedProjects.filter(
+        (p) => p.projectId === options.project || p.projectSlug === options.project
+      );
+      if (trackedProjects.length === 0) {
+        console.log(pc5.red(`Project "${options.project}" not found in tracked projects`));
+        process.exit(1);
+      }
+    }
+    const baseOutputDir = options.output || config.output?.baseDir || path4.resolve(process.cwd(), "src/porchestra/agents");
+    let totalAgents = 0;
+    let successCount = 0;
+    for (const project of trackedProjects) {
+      let agents = project.agents;
+      if (options.agent) {
+        agents = agents.filter(
+          (a) => a.agentId === options.agent || a.agentSlug === options.agent
+        );
+      }
+      if (agents.length === 0) continue;
+      console.log(pc5.bold(`
+\u{1F4E6} ${project.projectName}
+`));
+      totalAgents += agents.length;
+      for (let i = 0; i < agents.length; i++) {
+        const agent = agents[i];
+        const progress = `[${i + 1}/${agents.length}]`;
+        const spinner = ora2(`${progress} Fetching ${agent.agentName}...`).start();
+        try {
+          const toolsResponse = await apiClient.getAgentTools(
+            project.projectId,
+            agent.agentId,
+            options.env
+          );
+          spinner.text = `${progress} Generating code...`;
+          const normalizeToolset = (toolset = []) => toolset.map((t, idx) => ({
+            id: t.id ?? `toolset-${idx}`,
+            name: t.name,
+            description: t.description ?? "",
+            parameters: t.parameters ?? {},
+            returns: t.returns ?? null,
+            isBuiltin: t.isBuiltin ?? false,
+            builtinType: t.builtinType
+          }));
+          const rawToolConfig = toolsResponse?.components?.toolConfig?.content;
+          const parsedToolConfig = (() => {
+            if (typeof rawToolConfig === "string") {
+              try {
+                return JSON.parse(rawToolConfig);
+              } catch {
+                return void 0;
+              }
+            }
+            return rawToolConfig;
+          })();
+          const findToolArray = (value) => {
+            if (Array.isArray(value)) {
+              const hasNamedObjects = value.every((v) => v && typeof v === "object" && "name" in v);
+              return hasNamedObjects ? value : void 0;
+            }
+            if (value && typeof value === "object") {
+              if (Array.isArray(value.toolset)) return value.toolset;
+              if (Array.isArray(value.tools)) return value.tools;
+              for (const key of Object.keys(value)) {
+                const found = findToolArray(value[key]);
+                if (found) return found;
+              }
+            }
+            return void 0;
+          };
+          const toolsetFromConfig = findToolArray(parsedToolConfig) ?? [];
+          const resolvedTools = toolsResponse?.tools && toolsResponse.tools.length > 0 ? toolsResponse.tools : Array.isArray(toolsResponse?.toolset) ? normalizeToolset(toolsResponse.toolset) : normalizeToolset(toolsetFromConfig);
+          if (!toolsResponse?.agent || !toolsResponse?.components) {
+            throw new Error("Invalid tools response from API");
+          }
+          const outputDir = codeGenerator.calculateOutputPath(
+            baseOutputDir,
+            agent.folderPath,
+            toolsResponse.agent.name
+          );
+          await codeGenerator.generate({
+            agent: toolsResponse.agent,
+            tools: resolvedTools,
+            components: toolsResponse.components,
+            outputDir,
+            forceOverwrite: options.force || false
+          });
+          spinner.succeed(`${progress} ${agent.agentName} \u2192 ${pc5.gray(outputDir)}`);
+          successCount++;
+          await projectTracker.updateLastPulled(
+            project.projectId,
+            agent.agentId,
+            toolsResponse.agent.version
+          );
+        } catch (error) {
+          spinner.fail(`${progress} ${agent.agentName}`);
+          console.error(pc5.red(`   \u2717 ${error.message}`));
+        }
+      }
+    }
+    console.log(pc5.bold("\n\u2728 Pull Complete\n"));
+    if (successCount === totalAgents) {
+      console.log(`  ${pc5.green("\u2713")} Generated: ${successCount} / ${totalAgents} agents`);
+    } else if (successCount > 0) {
+      console.log(`  ${pc5.yellow("\u26A0")} Generated: ${successCount} / ${totalAgents} agents`);
+      console.log(`  ${pc5.red("\u2717")} Failed: ${totalAgents - successCount} agents`);
+    } else {
+      console.log(`  ${pc5.red("\u2717")} Failed: All ${totalAgents} agents`);
+    }
+    console.log(`  Output: ${pc5.gray(baseOutputDir)}`);
+    if (successCount > 0) {
+      console.log(pc5.gray("\nNext steps:"));
+      console.log(pc5.gray("  1. Implement tool functions in tool-impl.ts files"));
+      console.log(pc5.gray("  2. Import and use the tool dispatcher in your code"));
+    }
+    console.log();
+    if (successCount < totalAgents) {
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/config.ts
+import { Command as Command6 } from "commander";
+import pc6 from "picocolors";
+import { confirm as confirm3 } from "@inquirer/prompts";
+function createConfigCommand(configManager) {
+  const config = new Command6("config").description("Manage CLI configuration");
+  config.command("get <key>").description("Get a configuration value").action(async (key) => {
+    const cfg = await configManager.get();
+    const value = getNestedValue(cfg, key);
+    console.log(value !== void 0 ? value : pc6.gray("(not set)"));
+  });
+  config.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
+    await configManager.update((cfg) => {
+      return setNestedValue(cfg, key, parseValue(value));
+    });
+    console.log(pc6.green(`\u2713 Set ${key} = ${value}`));
+  });
+  config.command("list").description("List all configuration values").action(async () => {
+    const cfg = await configManager.get();
+    console.log(pc6.bold("\nConfiguration:"));
+    printConfig(cfg);
+  });
+  config.command("reset").description("Reset all configuration (WARNING: clears auth)").option("--force", "Skip confirmation").action(async (options) => {
+    if (!options.force) {
+      const confirmed = await confirm3({
+        message: "This will clear all config including login. Continue?",
+        default: false
+      });
+      if (!confirmed) return;
+    }
+    await configManager.clear();
+    console.log(pc6.green("\u2713 Configuration reset"));
+  });
+  return config;
+}
+function getNestedValue(obj, key) {
+  return key.split(".").reduce((o, k) => o?.[k], obj);
+}
+function setNestedValue(obj, key, value) {
+  const keys = key.split(".");
+  const last = keys.pop();
+  const target = keys.reduce((o, k) => {
+    if (!o[k]) o[k] = {};
+    return o[k];
+  }, obj);
+  target[last] = value;
+  return obj;
+}
+function parseValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (!isNaN(Number(value))) return Number(value);
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function printConfig(obj, prefix = "") {
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      console.log(`
+${pc6.cyan(fullKey)}:`);
+      printConfig(value, fullKey);
+    } else {
+      const displayValue = key.includes("token") ? pc6.gray("***hidden***") : value;
+      console.log(`  ${fullKey} = ${displayValue}`);
+    }
+  }
+}
+
+// src/commands/status.ts
+init_project_tracker();
+init_date();
+import { Command as Command7 } from "commander";
+import pc7 from "picocolors";
+function createStatusCommand(configManager) {
+  const projectTracker = new ProjectTracker(configManager);
+  return new Command7("status").description("Show CLI status and tracked projects").action(async () => {
+    const config = await configManager.get();
+    console.log(pc7.bold("\n\u{1F4CA} Porchestra CLI Status\n"));
+    if (config.auth?.token) {
+      const expiresAt = new Date(config.auth.expiresAt);
+      const daysUntilExpiry = Math.ceil(
+        (expiresAt.getTime() - Date.now()) / (1e3 * 60 * 60 * 24)
+      );
+      const expiryColor = daysUntilExpiry < 7 ? pc7.yellow : pc7.green;
+      console.log(pc7.bold("\u{1F511} Authentication"));
+      console.log(`  Status:   ${pc7.green("\u2713 Logged in")}`);
+      console.log(`  Device:   ${config.auth.deviceName}`);
+      console.log(`  Expires:  ${expiryColor(daysUntilExpiry + " days")} (${config.auth.expiresAt})`);
+    } else {
+      console.log(pc7.bold("\u{1F511} Authentication"));
+      console.log(`  Status:   ${pc7.yellow("\u2717 Not logged in")}`);
+      console.log(pc7.gray("  Run `porchestra login` to authenticate"));
+    }
+    console.log(pc7.bold("\n\u{1F517} API Configuration"));
+    console.log(`  URL:      ${config.api?.baseUrl || pc7.gray("(default)")}`);
+    if (config.api?.skipTlsVerify) {
+      console.log(pc7.yellow(`  \u26A0\uFE0F TLS verification disabled`));
+    }
+    const projects = await projectTracker.getTrackedProjects();
+    console.log(pc7.bold("\n\u{1F4C1} Tracked Projects"));
+    if (projects.length === 0) {
+      console.log(pc7.gray("  No projects tracked"));
+      console.log(pc7.gray("  Run `porchestra explore` to select projects"));
+    } else {
+      console.log(`  Projects: ${projects.length}`);
+      console.log(`  Agents:   ${projects.reduce((sum, p) => sum + p.agents.length, 0)}`);
+      projects.forEach((project) => {
+        const lastPulled = project.lastPulledAt ? formatDistanceToNow(new Date(project.lastPulledAt)) : pc7.gray("never");
+        console.log(pc7.gray(`
+  ${project.projectName}`));
+        project.agents.forEach((agent) => {
+          const agentPulled = agent.lastPulledAt ? formatDistanceToNow(new Date(agent.lastPulledAt)) : pc7.gray("pending");
+          console.log(pc7.gray(`    \u2514\u2500 ${agent.agentName} ${pc7.cyan(agent.folderPath)} (${agentPulled})`));
+        });
+        console.log(pc7.gray(`    Last pulled: ${lastPulled}`));
+      });
+    }
+    console.log(pc7.bold("\n\u{1F4C2} Output Configuration"));
+    console.log(`  Base dir: ${config.output?.baseDir || "./src/agents"}`);
+    console.log(`  Index files: ${config.output?.createIndexFiles ? "yes" : "no"}`);
+    console.log();
+  });
+}
+
+// src/commands/agents.ts
+init_project_tracker();
+init_date();
+import { Command as Command8 } from "commander";
+import { select as select2, confirm as confirm4 } from "@inquirer/prompts";
+import pc8 from "picocolors";
+function createAgentsCommand(configManager) {
+  const projectTracker = new ProjectTracker(configManager);
+  const listAction = async (options = {}) => {
+    let projects = await projectTracker.getTrackedProjects();
+    if (options.project) {
+      projects = projects.filter(
+        (project) => project.projectId === options.project || project.projectSlug === options.project
+      );
+      if (projects.length === 0) {
+        console.log(pc8.red(`No tracked project found for "${options.project}"`));
+        return;
+      }
+    }
+    if (options.json) {
+      console.log(JSON.stringify(projects, null, 2));
+      return;
+    }
+    console.log(pc8.bold("\n\u{1F4C1} Tracked Agents\n"));
+    if (projects.length === 0) {
+      console.log(pc8.gray("  No agents tracked. Run `porchestra explore` to add agents."));
+      console.log();
+      return;
+    }
+    let totalAgents = 0;
+    projects.forEach((project) => {
+      totalAgents += project.agents.length;
+      console.log(pc8.bold(`  ${project.projectName}`));
+      project.agents.forEach((agent) => {
+        const lastPulled = agent.lastPulledAt ? formatDistanceToNow(new Date(agent.lastPulledAt)) : "pending";
+        const version = agent.lastPulledVersion ? ` @ ${agent.lastPulledVersion}` : "";
+        console.log(`    \u2514\u2500 ${pc8.cyan(agent.agentName)}${version ? pc8.gray(version) : ""}`);
+        console.log(pc8.gray(`       ${agent.folderPath} (${lastPulled})`));
+      });
+      console.log();
+    });
+    console.log(pc8.gray(`Total: ${projects.length} project(s), ${totalAgents} agent(s)
+`));
+  };
+  const command = new Command8("agents").description("Manage tracked agents").action(async () => listAction());
+  command.command("list").description("List tracked agents").option("-p, --project <id>", "Filter by project id or slug").option("--json", "Output raw JSON for scripting").action(listAction);
+  command.command("remove [agent]").description("Stop tracking a specific agent").option("-p, --project <id>", "Project id or slug (disambiguates agents with the same slug)").option("-f, --force", "Skip confirmation prompt").action(async (agentArg, options) => {
+    let projects = await projectTracker.getTrackedProjects();
+    if (projects.length === 0) {
+      console.log(pc8.gray("No agents tracked. Run `porchestra explore` first."));
+      return;
+    }
+    if (options.project) {
+      projects = projects.filter(
+        (project) => project.projectId === options.project || project.projectSlug === options.project
+      );
+      if (projects.length === 0) {
+        console.log(pc8.red(`No tracked project found for "${options.project}"`));
+        return;
+      }
+    }
+    const candidates = projects.flatMap(
+      (project) => project.agents.map((agent) => ({
+        project,
+        agent,
+        value: `${project.projectId}:${agent.agentId}`
+      }))
+    );
+    let filtered = candidates;
+    if (agentArg) {
+      filtered = candidates.filter(
+        ({ agent }) => agent.agentId === agentArg || agent.agentSlug === agentArg
+      );
+    }
+    if (filtered.length === 0) {
+      const message = agentArg ? `No tracked agent found for "${agentArg}".` : "No tracked agents found.";
+      console.log(pc8.red(message));
+      return;
+    }
+    let target = filtered[0];
+    if (filtered.length > 1) {
+      const choice = await select2({
+        message: "Select an agent to stop tracking:",
+        choices: filtered.map(({ project, agent, value }) => ({
+          name: `${agent.agentName} ${pc8.gray(`(${project.projectName}) ${agent.folderPath}`)}`,
+          value
+        }))
+      });
+      target = filtered.find((candidate) => candidate.value === choice);
+    }
+    if (!options.force) {
+      const confirmed = await confirm4({
+        message: `Remove ${target.agent.agentName} from ${target.project.projectName}?`,
+        default: false
+      });
+      if (!confirmed) return;
+    }
+    const removed = await projectTracker.untrackAgent(
+      target.project.projectId,
+      target.agent.agentId
+    );
+    if (!removed) {
+      console.log(pc8.red("Agent was not removed (not found)."));
+      return;
+    }
+    const projectRemoved = target.project.agents.length === 1;
+    console.log(pc8.green(`\u2713 Stopped tracking ${target.agent.agentName}`));
+    console.log(pc8.gray(`  Project: ${target.project.projectName}`));
+    if (projectRemoved) {
+      console.log(pc8.gray("  Project removed from tracking because it has no remaining agents."));
+    }
+  });
+  return command;
+}
+
+// src/index.ts
+var packageJson = { version: "1.0.0" };
+process.on("unhandledRejection", (error) => {
+  console.error(pc9.red("\n\u2717 Unexpected error:"));
+  console.error(error);
+  process.exit(1);
+});
+process.on("uncaughtException", (error) => {
+  console.error(pc9.red("\n\u2717 Fatal error:"));
+  console.error(error);
+  process.exit(1);
+});
+async function main() {
+  const configManager = new ConfigManager();
+  const authService = new AuthService(configManager);
+  new TokenManager(configManager);
+  const apiClient = new ApiClient(configManager);
+  const codeGenerator = new CodeGenerator();
+  await authService.checkAndRefreshTokenIfNeeded();
+  const program = new Command9().name("porchestra").description("CLI for Porchestra - Generate LLM tool handlers").version(packageJson.version).configureOutput({
+    writeErr: (str) => process.stderr.write(str),
+    outputError: (str, write) => write(pc9.red(str))
+  });
+  program.option("--api-url <url>", "Override API URL").option("--config-dir <dir>", "Override config directory");
+  program.addCommand(createLoginCommand(configManager, authService));
+  program.addCommand(createLogoutCommand(configManager, authService));
+  program.addCommand(createWhoamiCommand(configManager, authService));
+  program.addCommand(createExploreCommand(configManager, apiClient));
+  program.addCommand(createPullCommand(configManager, apiClient, codeGenerator));
+  program.addCommand(createConfigCommand(configManager));
+  program.addCommand(createStatusCommand(configManager));
+  program.addCommand(createAgentsCommand(configManager));
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  if (error instanceof PorchestraError) {
+    console.error(pc9.red(`
+\u2717 ${error.message}`));
+    if (process.env.DEBUG) {
+      console.error(pc9.gray(error.stack));
+    }
+  } else {
+    console.error(pc9.red(`
+\u2717 Unexpected error: ${error.message}`));
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map