@porchestra/cli 1.0.0 → 1.0.2

package/src/core/auth/token-manager.ts

@@ -1,47 +0,0 @@
-import { ConfigManager } from '../config/config-manager.js';
-
-export class TokenManager {
-  constructor(private configManager: ConfigManager) {}
-
-  async getToken(): Promise<string | undefined> {
-    const config = await this.configManager.get();
-    return config.auth?.token;
-  }
-
-  async getTokenId(): Promise<string | undefined> {
-    const config = await this.configManager.get();
-    return config.auth?.tokenId;
-  }
-
-  async getExpiresAt(): Promise<string | undefined> {
-    const config = await this.configManager.get();
-    return config.auth?.expiresAt;
-  }
-
-  async isAuthenticated(): Promise<boolean> {
-    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 > new Date();
-  }
-
-  async getDaysUntilExpiry(): Promise<number | null> {
-    const expiresAt = await this.getExpiresAt();
-    if (!expiresAt) return null;
-
-    const expiryDate = new Date(expiresAt);
-    const now = new Date();
-    const diffMs = expiryDate.getTime() - now.getTime();
-    return Math.ceil(diffMs / (1000 * 60 * 60 * 24));
-  }
-
-  async isExpiringSoon(days = 7): Promise<boolean> {
-    const daysUntilExpiry = await this.getDaysUntilExpiry();
-    if (daysUntilExpiry === null) return false;
-    return daysUntilExpiry <= days;
-  }
-}

package/src/core/config/config-manager.ts

@@ -1,107 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
-import { z } from 'zod';
-import { CliConfig, CliConfigSchema } from './config-schema.js';
-
-const DEFAULT_CONFIG_DIR = path.join(os.homedir(), '.porchestra');
-const CONFIG_FILE = 'config.json';
-
-export class ConfigManager {
-  private configPath: string;
-  private config: CliConfig | null = null;
-
-  constructor() {
-    const configDir = process.env.PORCHESTRA_CONFIG_DIR || DEFAULT_CONFIG_DIR;
-    this.configPath = path.join(configDir, CONFIG_FILE);
-  }
-
-  async load(): Promise<CliConfig> {
-    try {
-      const data = await fs.readFile(this.configPath, 'utf-8');
-      const parsed = JSON.parse(data);
-      
-      // STRICT VALIDATION - throws on error
-      const validated = CliConfigSchema.parse(parsed);
-      this.config = validated;
-      return validated;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        // Return default config
-        const defaultConfig = { version: '1.0.0' } as const;
-        this.config = CliConfigSchema.parse(defaultConfig);
-        return this.config;
-      }
-      
-      // THROW on validation errors
-      if (error instanceof z.ZodError) {
-        console.error('❌ 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: CliConfig): Promise<void> {
-    try {
-      // STRICT VALIDATION before save
-      const validated = CliConfigSchema.parse(config);
-      
-      // Ensure directory exists
-      const configDir = path.dirname(this.configPath);
-      await fs.mkdir(configDir, { recursive: true });
-      
-      // Atomic write (write to temp, then rename)
-      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 z.ZodError) {
-        console.error('❌ 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(): Promise<CliConfig> {
-    if (!this.config) {
-      return this.load();
-    }
-    return this.config;
-  }
-
-  async update(updater: (config: CliConfig) => CliConfig): Promise<void> {
-    const config = await this.get();
-    const updated = updater({ ...config }); // Create new object
-    await this.save(updated);
-  }
-
-  async clear(): Promise<void> {
-    try {
-      await fs.unlink(this.configPath);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-        throw error;
-      }
-    }
-    this.config = null;
-  }
-
-  getConfigPath(): string {
-    return this.configPath;
-  }
-}

package/src/core/config/config-schema.ts

@@ -1,56 +0,0 @@
-import { z } from 'zod';
-
-// Simplified datetime validation - just accepts any string
-const DateTimeStringSchema = z.string().optional();
-
-export const 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(),
-});
-
-export const TrackedProjectSchema = z.object({
-  projectId: z.string().uuid(),
-  projectName: z.string(),
-  projectSlug: z.string(),
-  selectedAt: DateTimeStringSchema,
-  agents: z.array(TrackedAgentSchema),
-  lastPulledAt: DateTimeStringSchema.optional(),
-});
-
-export const 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'),
-});
-
-export type TrackedAgent = z.infer<typeof TrackedAgentSchema>;
-export type TrackedProject = z.infer<typeof TrackedProjectSchema>;
-export type CliConfig = z.infer<typeof CliConfigSchema>;

package/src/core/config/project-tracker.ts

@@ -1,158 +0,0 @@
-import { ConfigManager } from './config-manager.js';
-import { TrackedProject, TrackedAgent } from './config-schema.js';
-
-export interface ProjectBrief {
-  id: string;
-  name: string;
-  slug: string;
-}
-
-export interface AgentBrief {
-  id: string;
-  name: string;
-  slug: string;
-  folderPath: string;
-}
-
-export class ProjectTracker {
-  constructor(private configManager: ConfigManager) {}
-
-  async getTrackedProjects(): Promise<TrackedProject[]> {
-    const config = await this.configManager.get();
-    return config.trackedProjects || [];
-  }
-
-  async getTrackedAgents(projectId: string): Promise<TrackedAgent[]> {
-    const config = await this.configManager.get();
-    const project = config.trackedProjects?.find(p => p.projectId === projectId);
-    return project?.agents || [];
-  }
-
-  async listTrackedAgents(): Promise<Array<{ project: TrackedProject; agent: TrackedAgent }>> {
-    const projects = await this.getTrackedProjects();
-    return projects.flatMap(project =>
-      project.agents.map(agent => ({ project, agent }))
-    );
-  }
-
-  async trackProject(project: ProjectBrief, agents: AgentBrief[]): Promise<void> {
-    await this.configManager.update((config) => {
-      const existingIndex = config.trackedProjects.findIndex(
-        p => p.projectId === project.id
-      );
-
-      const trackedAgents: TrackedAgent[] = agents.map(agent => ({
-        agentId: agent.id,
-        agentName: agent.name,
-        agentSlug: agent.slug,
-        folderPath: agent.folderPath,
-        selectedAt: new Date().toISOString(),
-      }));
-
-      const trackedProject: TrackedProject = {
-        projectId: project.id,
-        projectName: project.name,
-        projectSlug: project.slug,
-        selectedAt: 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: string): Promise<void> {
-    await this.configManager.update((config) => ({
-      ...config,
-      trackedProjects: config.trackedProjects.filter(
-        p => p.projectId !== projectId
-      ),
-    }));
-  }
-
-  async untrackAgent(projectId: string, agentId: string): Promise<boolean> {
-    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: string,
-    agentId: string,
-    version: string
-  ): Promise<void> {
-    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 = 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(): Promise<{ projectCount: number; agentCount: number }> {
-    const projects = await this.getTrackedProjects();
-    return {
-      projectCount: projects.length,
-      agentCount: projects.reduce((sum, p) => sum + p.agents.length, 0),
-    };
-  }
-}

package/src/core/generators/code-generator.ts

@@ -1,329 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import Handlebars from 'handlebars';
-import { calculateAgentOutputPath } from '../../utils/path-utils.js';
-import { AgentToolsResponse } from '../../types/index.js';
-import { logger } from '../../utils/logger.js';
-
-interface GenerateOptions {
-  agent: AgentToolsResponse['agent'];
-  tools: AgentToolsResponse['tools'];
-  components: AgentToolsResponse['components'];
-  outputDir: string;
-  forceOverwrite: boolean;
-}
-
-interface ToolData {
-  name: string;
-  description: string;
-  parameters: object;
-  returns: object | null;
-  isBuiltin?: boolean;
-  builtinType?: string;
-}
-
-interface TemplateData {
-  agentName: string;
-  version: string;
-  generatedAt: string;
-  tools: ToolData[];
-  variableSchema: object | null;
-  inputSchema: object | null;
-  responseSchema: object | null;
-  responseJsonSchema: object;
-}
-
-// Register Handlebars helpers
-Handlebars.registerHelper('pascalCase', function(str: string) {
-  return str
-    .replace(/[-_\s](.)/g, (_, char) => char.toUpperCase())
-    .replace(/^(.)/, (_, char) => char.toUpperCase());
-});
-
-Handlebars.registerHelper('camelCase', function(str: string) {
-  return str
-    .replace(/[-_\s](.)/g, (_, char) => char.toUpperCase())
-    .replace(/^(.)/, (_, char) => char.toLowerCase());
-});
-
-Handlebars.registerHelper('zodType', function(schema: any) {
-  return jsonSchemaToZodType(schema);
-});
-
-Handlebars.registerHelper('json', function(value: any) {
-  return JSON.stringify(value ?? {}, null, 2);
-});
-
-function jsonSchemaToZodType(schema: any): string {
-  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: string) => `'${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 !== undefined) zod += `.min(${schema.minimum})`;
-      if (schema.maximum !== undefined) 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]: [string, any]) => {
-        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({\n${props.join(',\n')}\n})`;
-      if (schema.additionalProperties === false) zod += '.strict()';
-      if (schema.nullable) zod += '.nullable()';
-      return zod;
-    }
-    default:
-      return 'z.any()';
-  }
-}
-
-export class CodeGenerator {
-  private schemasTemplate: Handlebars.TemplateDelegate;
-  private toolsTemplate: Handlebars.TemplateDelegate;
-  private indexTemplate: Handlebars.TemplateDelegate;
-
-  constructor() {
-    this.schemasTemplate = Handlebars.compile(schemasTemplateSource);
-    this.toolsTemplate = Handlebars.compile(toolsTemplateSource);
-    this.indexTemplate = Handlebars.compile(indexTemplateSource);
-  }
-
-  async generate(options: GenerateOptions): Promise<void> {
-    const { agent, tools, components, outputDir } = options;
-
-    await fs.mkdir(outputDir, { recursive: true });
-
-    const responseJsonSchema = (components?.responseSchema?.content as object) || {};
-
-    const templateData: TemplateData = {
-      agentName: agent?.name || 'Unknown Agent',
-      version: agent?.version || 'unknown',
-      generatedAt: 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: (components?.variableSchema?.content as object) || null,
-      inputSchema: (components?.inputSchema?.content as object) || null,
-      responseSchema: (components?.responseSchema?.content as object) || null,
-      responseJsonSchema,
-    };
-
-    // Generate ast.json (always overwrite)
-    const astPath = path.join(outputDir, 'ast.json');
-    const astContent = JSON.stringify(components?.ast?.content ?? {}, null, 2);
-    await fs.writeFile(astPath, astContent, 'utf-8');
-
-    // Generate config.ts (always overwrite)
-    const configPath = path.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 fs.writeFile(configPath, configContent, 'utf-8');
-
-    // Generate schemas.ts (always overwrite)
-    const schemasPath = path.join(outputDir, 'schemas.ts');
-    const schemasContent = this.schemasTemplate(templateData);
-    await fs.writeFile(schemasPath, schemasContent, 'utf-8');
-
-    // Generate tools.ts (always overwrite)
-    const toolsPath = path.join(outputDir, 'tools.ts');
-    const toolsContent = this.toolsTemplate(templateData);
-    await fs.writeFile(toolsPath, toolsContent, 'utf-8');
-
-    // Generate index.ts (always overwrite)
-    const indexPath = path.join(outputDir, 'index.ts');
-    const indexContent = this.indexTemplate(templateData);
-    await fs.writeFile(indexPath, indexContent, 'utf-8');
-  }
-
-  calculateOutputPath(baseDir: string, folderPath: string, agentName: string): string {
-    return calculateAgentOutputPath(baseDir, folderPath, agentName);
-  }
-}
-
-// Template sources
-const 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;
-`;
-
-const 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}\`);
-  }
-}
-`;
-
-const 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;
-  }
-}
-`;