@porchestra/cli 1.0.0 → 1.0.2

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

@@ -1,59 +0,0 @@
-import { z } from 'zod';
-
-export function jsonSchemaToZod(schema: any): z.ZodTypeAny {
-  switch (schema.type) {
-    case 'string': {
-      let stringSchema = z.string();
-      if (schema.minLength) stringSchema = stringSchema.min(schema.minLength);
-      if (schema.maxLength) stringSchema = stringSchema.max(schema.maxLength);
-      if (schema.pattern) stringSchema = stringSchema.regex(new RegExp(schema.pattern));
-      if (schema.enum) return z.enum(schema.enum);
-      return schema.nullable ? stringSchema.nullable() : stringSchema;
-    }
-
-    case 'number':
-    case 'integer': {
-      let numberSchema = schema.type === 'integer' ? z.number().int() : z.number();
-      if (schema.minimum !== undefined) numberSchema = numberSchema.min(schema.minimum);
-      if (schema.maximum !== undefined) numberSchema = numberSchema.max(schema.maximum);
-      return schema.nullable ? numberSchema.nullable() : numberSchema;
-    }
-
-    case 'boolean': {
-      const boolSchema = z.boolean();
-      return schema.nullable ? boolSchema.nullable() : boolSchema;
-    }
-
-    case 'array': {
-      const itemSchema = jsonSchemaToZod(schema.items);
-      let arraySchema = z.array(itemSchema);
-      if (schema.minItems) arraySchema = arraySchema.min(schema.minItems);
-      if (schema.maxItems) arraySchema = arraySchema.max(schema.maxItems);
-      return schema.nullable ? arraySchema.nullable() : arraySchema;
-    }
-
-    case 'object': {
-      const shape: Record<string, z.ZodTypeAny> = {};
-      const required = new Set(schema.required || []);
-      
-      for (const [key, propSchema] of Object.entries(schema.properties || {})) {
-        let fieldSchema = jsonSchemaToZod(propSchema as any);
-        if (!required.has(key)) {
-          fieldSchema = fieldSchema.optional();
-        }
-        shape[key] = fieldSchema;
-      }
-      
-      let objectSchema = z.object(shape);
-      // Note: strict() is not applied to keep the schema flexible
-      return schema.nullable ? objectSchema.nullable() : objectSchema;
-    }
-
-    default:
-      if (schema.anyOf || schema.oneOf) {
-        const schemas = (schema.anyOf || schema.oneOf).map(jsonSchemaToZod);
-        return z.union([schemas[0], schemas[1], ...schemas.slice(2)]);
-      }
-      return z.any();
-  }
-}

package/src/index.ts

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import pc from 'picocolors';
-import { ConfigManager } from './core/config/config-manager.js';
-import { AuthService } from './core/auth/auth-service.js';
-import { TokenManager } from './core/auth/token-manager.js';
-import { ApiClient } from './core/api/client.js';
-import { CodeGenerator } from './core/generators/code-generator.js';
-import { createLoginCommand } from './commands/login.js';
-import { createLogoutCommand } from './commands/logout.js';
-import { createWhoamiCommand } from './commands/whoami.js';
-import { createExploreCommand } from './commands/explore.js';
-import { createPullCommand } from './commands/pull.js';
-import { createConfigCommand } from './commands/config.js';
-import { createStatusCommand } from './commands/status.js';
-import { createAgentsCommand } from './commands/agents.js';
-import { PorchestraError } from './utils/errors.js';
-
-const packageJson = { version: '1.0.0' };
-
-// Global error handlers
-process.on('unhandledRejection', (error) => {
-  console.error(pc.red('\n✗ Unexpected error:'));
-  console.error(error);
-  process.exit(1);
-});
-
-process.on('uncaughtException', (error) => {
-  console.error(pc.red('\n✗ Fatal error:'));
-  console.error(error);
-  process.exit(1);
-});
-
-async function main() {
-  // Initialize core services
-  const configManager = new ConfigManager();
-  const authService = new AuthService(configManager);
-  // TokenManager is available for future token operations
-  new TokenManager(configManager);
-  const apiClient = new ApiClient(configManager);
-  const codeGenerator = new CodeGenerator();
-
-  // Check token expiration and refresh if needed
-  await authService.checkAndRefreshTokenIfNeeded();
-
-  // Create CLI program
-  const program = new Command()
-    .name('porchestra')
-    .description('CLI for Porchestra - Generate LLM tool handlers')
-    .version(packageJson.version)
-    .configureOutput({
-      writeErr: (str) => process.stderr.write(str),
-      outputError: (str, write) => write(pc.red(str))
-    });
-
-  // Add global options
-  program
-    .option('--api-url <url>', 'Override API URL')
-    .option('--config-dir <dir>', 'Override config directory');
-
-  // Register commands
-  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));
-
-  // Parse arguments
-  await program.parseAsync(process.argv);
-}
-
-main().catch((error) => {
-  if (error instanceof PorchestraError) {
-    console.error(pc.red(`\n✗ ${error.message}`));
-    if (process.env.DEBUG) {
-      console.error(pc.gray(error.stack));
-    }
-  } else {
-    console.error(pc.red(`\n✗ Unexpected error: ${(error as Error).message}`));
-  }
-  process.exit(1);
-});

package/src/types/index.ts

@@ -1,214 +0,0 @@
-// Authentication Types
-export interface ApiResponse<T> {
-  statusCode: number;
-  message: string;
-  data: T;
-  timestamp: string;
-  path: string;
-}
-
-export interface CliTokenRequest {
-  deviceName?: string;
-  deviceInfo?: {
-    os: string;
-    version: string;
-    cliVersion: string;
-  };
-}
-
-export interface CliTokenResponse {
-  token: string;
-  tokenId: string;
-  expiresAt: string;
-  issuedAt: string;
-  deviceName: string;
-}
-
-export interface CliTokenRefreshRequest {
-  tokenId: string;
-  currentToken: string;
-}
-
-export interface CliTokenRefreshResponse {
-  token: string;
-  tokenId: string;
-  expiresAt: string;
-  refreshedAt: string;
-}
-
-export interface CliTokenRevokeRequest {
-  revokeAll?: boolean;
-}
-
-export interface CliTokenRevokeResponse {
-  revoked: boolean;
-  revokedCount?: number;
-  revokedAt: string;
-}
-
-export interface CliTokensListResponse {
-  tokens: Array<{
-    tokenId: string;
-    deviceName: string;
-    deviceInfo: {
-      os: string;
-      version: string;
-      cliVersion: string;
-    };
-    issuedAt: string;
-    expiresAt: string;
-    lastUsedAt: string | null;
-    lastUsedIp: string | null;
-    isCurrent: boolean;
-  }>;
-  total: number;
-  maxAllowed: number;
-}
-
-// Project Types
-export interface ProjectsBriefResponse {
-  projects: Array<{
-    id: string;
-    name: string;
-    slug: string;
-    description: string | null;
-    agentCount: number;
-    environments: Array<{
-      name: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT';
-      hasPublishedVersion: boolean;
-    }>;
-    lastModifiedAt: string;
-  }>;
-  total: number;
-}
-
-export interface AgentsListQuery {
-  environment?: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT';
-}
-
-export interface AgentsListResponse {
-  project: {
-    id: string;
-    name: string;
-    slug: string;
-  };
-  environment: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT';
-  agents: Array<{
-    id: string;
-    name: string;
-    slug: string;
-    folderPath: string;
-    description: string | null;
-    version: string;
-    toolCount: number;
-    lastUpdatedAt: string;
-    isPublished: boolean;
-  }>;
-  versionResolution: {
-    source: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT';
-    note: string;
-  };
-}
-
-export interface AgentDetailQuery {
-  environment?: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT';
-}
-
-export interface AgentDetailResponse {
-  agent: {
-    id: string;
-    name: string;
-    slug: string;
-    folderPath: string;
-    description: string | null;
-    instructions: string | null;
-    model: string;
-    temperature: number;
-    version: string;
-    versionId: string;
-    environment: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT';
-    createdAt: string;
-    updatedAt: string;
-    publishedAt: string | null;
-  };
-  versionResolution: {
-    source: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT';
-    note: string;
-  };
-}
-
-// Tools Types
-export interface AgentToolsQuery {
-  environment?: 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT';
-}
-
-export interface AgentToolsResponse {
-  agent: {
-    id: string;
-    name: string;
-    folderPath: string;
-    version: string;
-  };
-  tools?: Array<{
-    id: string;
-    name: string;
-    description: string;
-    parameters: object;
-    returns: object | null;
-    isBuiltin: boolean;
-    builtinType?: string;
-  }>;
-  // Legacy/alternate API shape where tools are provided under `toolset`
-  toolset?: Array<{
-    name: string;
-    description?: string;
-    parameters?: object;
-    returns?: object | null;
-    isBuiltin?: boolean;
-    builtinType?: string;
-    id?: string;
-  }>;
-  components: {
-    ast: { id: string; content: unknown } | null;
-    modelConfig: { id: string; content: unknown } | null;
-    inputSchema: { id: string; content: unknown } | null;
-    variableSchema: { id: string; content: unknown } | null;
-    responseSchema: { id: string; content: unknown } | null;
-    toolConfig: { id: string; content: unknown } | null;
-  };
-  total: number;
-}
-
-// User Types
-export interface UserInfo {
-  email: string;
-  name: string;
-  organization: string;
-}
-
-// CLI Config Types
-export interface CliConfigResponse {
-  api: {
-    version: string;
-    minCliVersion: string;
-    recommendedCliVersion: string;
-    deprecatedCliVersions: string[];
-  };
-  features: {
-    codeGeneration: boolean;
-    multiAgent: boolean;
-    onPremise: boolean;
-    customPaths: boolean;
-  };
-  limits: {
-    maxTokensPerUser: number;
-    tokenExpiryDays: number;
-    exportCacheHours: number;
-    maxToolsPerAgent: number;
-  };
-  endpoints: {
-    webApp: string;
-    documentation: string;
-    support: string;
-  };
-}

package/src/utils/date.ts

@@ -1,23 +0,0 @@
-export function formatDistanceToNow(date: Date): string {
-  const now = new Date();
-  const diffMs = now.getTime() - date.getTime();
-  const diffSecs = Math.floor(diffMs / 1000);
-  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];
-}
-
-export function formatDate(dateStr: string): string {
-  const date = new Date(dateStr);
-  return date.toLocaleDateString('en-US', {
-    year: 'numeric',
-    month: 'short',
-    day: 'numeric',
-  });
-}

package/src/utils/errors.ts

@@ -1,38 +0,0 @@
-export class PorchestraError extends Error {
-  constructor(message: string, public code: string) {
-    super(message);
-    this.name = 'PorchestraError';
-  }
-}
-
-export class AuthenticationError extends PorchestraError {
-  constructor(message: string, public retryable = false) {
-    super(message, 'AUTH_ERROR');
-    this.name = 'AuthenticationError';
-  }
-}
-
-export class NetworkError extends PorchestraError {
-  constructor(
-    message: string,
-    public statusCode?: number,
-    public retryable = true
-  ) {
-    super(message, 'NETWORK_ERROR');
-    this.name = 'NetworkError';
-  }
-}
-
-export class ValidationError extends PorchestraError {
-  constructor(message: string, public field?: string) {
-    super(message, 'VALIDATION_ERROR');
-    this.name = 'ValidationError';
-  }
-}
-
-export class FileSystemError extends PorchestraError {
-  constructor(message: string, public path: string) {
-    super(message, 'FS_ERROR');
-    this.name = 'FileSystemError';
-  }
-}

package/src/utils/logger.ts

@@ -1,11 +0,0 @@
-import pc from 'picocolors';
-
-export const logger = {
-  info: (msg: string) => console.log(msg),
-  success: (msg: string) => console.log(pc.green(msg)),
-  error: (msg: string) => console.error(pc.red(msg)),
-  warn: (msg: string) => console.log(pc.yellow(msg)),
-  gray: (msg: string) => console.log(pc.gray(msg)),
-  bold: (msg: string) => console.log(pc.bold(msg)),
-  cyan: (msg: string) => console.log(pc.cyan(msg)),
-};

package/src/utils/path-utils.ts

@@ -1,47 +0,0 @@
-import path from 'path';
-import { promises as fs } from 'fs';
-
-export function normalizeFolderPath(folderPath: string): string {
-  let normalized = folderPath.replace(/^\//, '');
-  normalized = normalized.replace(/\/+/g, '/');
-  normalized = normalized
-    .split('/')
-    .map(segment => sanitizePathSegment(segment))
-    .join('/');
-  normalized = normalized.replace(/\/$/, '');
-  return normalized;
-}
-
-function sanitizePathSegment(segment: string): string {
-  return segment
-    .replace(/[^a-zA-Z0-9-_]/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .replace(/-+/g, '-');
-}
-
-export function calculateOutputPath(
-  baseDir: string,
-  folderPath: string,
-  filename?: string
-): string {
-  const normalized = normalizeFolderPath(folderPath);
-  const fullPath = path.join(baseDir, normalized);
-  return filename ? path.join(fullPath, filename) : fullPath;
-}
-
-export function calculateAgentOutputPath(
-  baseDir: string,
-  folderPath: string,
-  agentName: string,
-  filename?: string
-): string {
-  const normalizedFolder = normalizeFolderPath(folderPath);
-  const normalizedAgent = sanitizePathSegment(agentName);
-  const fullPath = path.join(baseDir, normalizedFolder, normalizedAgent);
-  return filename ? path.join(fullPath, filename) : fullPath;
-}
-
-export async function ensureDirectory(filePath: string): Promise<void> {
-  const dir = path.dirname(filePath);
-  await fs.mkdir(dir, { recursive: true });
-}

package/tests/unit/config-manager.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
-import { ConfigManager } from '../../src/core/config/config-manager.js';
-
-describe('ConfigManager', () => {
-  let tempDir: string;
-  let configManager: ConfigManager;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'porchestra-test-'));
-    process.env.PORCHESTRA_CONFIG_DIR = tempDir;
-    configManager = new ConfigManager();
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-    delete process.env.PORCHESTRA_CONFIG_DIR;
-  });
-
-  it('should create default config when none exists', async () => {
-    const config = await configManager.load();
-    expect(config.version).toBe('1.0.0');
-    expect(config.trackedProjects).toEqual([]);
-    expect(config.api?.baseUrl).toBe('https://api.porchestra.io/v1');
-  });
-
-  it('should save and load config', async () => {
-    const config = await configManager.load();
-    config.auth = {
-      token: 'test-token',
-      tokenId: '550e8400-e29b-41d4-a716-446655440000',
-      expiresAt: '2025-12-31T23:59:59Z',
-      deviceName: 'Test Device'
-    };
-    
-    await configManager.save(config);
-    
-    // Create new manager to test loading from disk
-    const newManager = new ConfigManager();
-    const loaded = await newManager.load();
-    
-    expect(loaded.auth?.token).toBe('test-token');
-    expect(loaded.auth?.deviceName).toBe('Test Device');
-  });
-
-  it('should update config with updater function', async () => {
-    await configManager.load();
-    
-    await configManager.update((cfg) => ({
-      ...cfg,
-      api: {
-        ...cfg.api,
-        baseUrl: 'https://custom.api.com/v1'
-      }
-    }));
-    
-    const config = await configManager.get();
-    expect(config.api?.baseUrl).toBe('https://custom.api.com/v1');
-  });
-
-  it('should clear config', async () => {
-    const config = await configManager.load();
-    config.auth = { token: 'test' };
-    await configManager.save(config);
-    
-    await configManager.clear();
-    
-    // After clear, should return default config
-    const newConfig = await configManager.load();
-    expect(newConfig.auth).toBeUndefined();
-  });
-});

package/tests/unit/config-schema.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CliConfigSchema, TrackedProjectSchema } from '../../src/core/config/config-schema.js';
-
-describe('config-schema', () => {
-  it('should validate a valid config', () => {
-    const validConfig = {
-      version: '1.0.0',
-      auth: {
-        token: 'test-token',
-        tokenId: '550e8400-e29b-41d4-a716-446655440000',
-        expiresAt: '2025-12-31T23:59:59Z',
-        deviceName: 'Test Device'
-      },
-      api: {
-        baseUrl: 'https://api.porchestra.io/v1',
-        skipTlsVerify: false
-      },
-      trackedProjects: [],
-      output: {
-        baseDir: './src/agents',
-        createIndexFiles: true
-      }
-    };
-
-    const result = CliConfigSchema.safeParse(validConfig);
-    expect(result.success).toBe(true);
-  });
-
-  it('should apply defaults for missing fields', () => {
-    const minimalConfig = {
-      version: '1.0.0'
-    };
-
-    const result = CliConfigSchema.parse(minimalConfig);
-    expect(result.api?.baseUrl).toBe('https://api.porchestra.io/v1');
-    expect(result.output?.baseDir).toBe('./src/agents');
-    expect(result.trackedProjects).toEqual([]);
-  });
-
-  it('should reject invalid version', () => {
-    const invalidConfig = {
-      version: '2.0.0'
-    };
-
-    const result = CliConfigSchema.safeParse(invalidConfig);
-    expect(result.success).toBe(false);
-  });
-
-  it('should validate tracked project schema', () => {
-    const validProject = {
-      projectId: '550e8400-e29b-41d4-a716-446655440000',
-      projectName: 'Test Project',
-      projectSlug: 'test-project',
-      selectedAt: '2025-01-30T12:00:00Z',
-      agents: []
-    };
-
-    const result = TrackedProjectSchema.safeParse(validProject);
-    expect(result.success).toBe(true);
-  });
-});

package/tests/unit/path-utils.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  normalizeFolderPath,
-  calculateOutputPath,
-} from '../../src/utils/path-utils.js';
-
-describe('path-utils', () => {
-  describe('normalizeFolderPath', () => {
-    it('should remove leading slash', () => {
-      expect(normalizeFolderPath('/main/x-agent/')).toBe('main/x-agent');
-    });
-
-    it('should handle paths without leading slash', () => {
-      expect(normalizeFolderPath('y-agent')).toBe('y-agent');
-    });
-
-    it('should replace multiple slashes', () => {
-      expect(normalizeFolderPath('//legacy//agents//')).toBe('/legacy/agents');
-    });
-
-    it('should sanitize special characters', () => {
-      expect(normalizeFolderPath('My Agent (v2)')).toBe('My-Agent-v2');
-    });
-
-    it('should handle empty path', () => {
-      expect(normalizeFolderPath('/')).toBe('');
-    });
-
-    it('should prevent directory traversal', () => {
-      expect(normalizeFolderPath('../malicious')).toBe('/malicious');
-    });
-  });
-
-  describe('calculateOutputPath', () => {
-    it('should calculate correct output path', () => {
-      const result = calculateOutputPath(
-        './src/agents',
-        'main/x-agent',
-        'tool-schemas.ts'
-      );
-      expect(result).toMatch(/src[\\/]agents[\\/]main[\\/]x-agent[\\/]tool-schemas\.ts/);
-    });
-
-    it('should handle empty folder path', () => {
-      const result = calculateOutputPath(
-        './src/agents',
-        '/',
-        'tool-schemas.ts'
-      );
-      expect(result).toMatch(/src[\\/]agents[\\/]tool-schemas\.ts$/);
-    });
-  });
-});