@studio-foundation/cli 0.3.0-beta.1 → 0.3.0-beta.6

package/src/config.ts

@@ -1,101 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { resolve, join } from 'node:path';
-import yaml from 'js-yaml';
-import { findStudioDir } from './studio-dir.js';
-
-export interface StudioConfig {
-  providers?: {
-    openai?: { apiKey: string };
-    anthropic?: { apiKey: string };
-    ollama?: { baseUrl?: string };
-  };
-  paths?: {
-    configs?: string;
-    projects_dir?: string;
-    pipelines?: string;
-  };
-  defaults?: {
-    provider?: string;
-    model?: string;
-  };
-  api?: {
-    key?: string;
-    port?: number;
-  };
-  integrations?: Record<string, Record<string, unknown>>;
-  db?: {
-    type?: 'sqlite' | 'postgres' | 'inmemory';
-    url?: string;   // required when type is 'postgres'
-  };
-  /** Resolved path to .studio/ dir — set at load time, not from YAML */
-  resolvedStudioDir?: string;
-}
-
-const LEGACY_CONFIG_NAMES = ['.studiorc.yaml', '.studiorc.yml'];
-
-export async function loadConfig(configPath?: string, cwd?: string): Promise<StudioConfig> {
-  const effectiveCwd = cwd ?? process.cwd();
-
-  if (configPath) {
-    return loadFromFile(resolve(configPath));
-  }
-
-  // 1. Try .studio/config.yaml (new standard)
-  const studioDir = await findStudioDir(effectiveCwd);
-  if (studioDir) {
-    const studioConfig = join(studioDir, 'config.yaml');
-    try {
-      const config = await loadFromFile(studioConfig);
-      config.resolvedStudioDir = studioDir;
-      return config;
-    } catch {
-      // .studio/ exists but no config.yaml — still set studioDir for path resolution
-      return { resolvedStudioDir: studioDir };
-    }
-  }
-
-  // 2. Fallback: .studiorc.yaml / .studiorc.yml at cwd
-  for (const name of LEGACY_CONFIG_NAMES) {
-    const filePath = resolve(effectiveCwd, name);
-    try {
-      return await loadFromFile(filePath);
-    } catch {
-      // try next
-    }
-  }
-
-  return {};
-}
-
-async function loadFromFile(filePath: string): Promise<StudioConfig> {
-  let raw: string;
-  try {
-    raw = await readFile(filePath, 'utf-8');
-  } catch {
-    throw new Error(`Config file not found: ${filePath}`);
-  }
-
-  const resolved = resolveEnvVars(raw);
-
-  let parsed: unknown;
-  try {
-    parsed = yaml.load(resolved);
-  } catch (err) {
-    throw new Error(
-      `Failed to parse config ${filePath}: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-
-  if (!parsed || typeof parsed !== 'object') {
-    return {};
-  }
-
-  return parsed as StudioConfig;
-}
-
-export function resolveEnvVars(content: string): string {
-  return content.replace(/\$\{([^}]+)\}/g, (_match, varName: string) => {
-    const value = process.env[varName.trim()];
-    return value === undefined ? '' : value;
-  });
-}

package/src/index.ts

@@ -1,201 +0,0 @@
-#!/usr/bin/env node
-
-import 'dotenv/config';
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { runCommand } from './commands/run.js';
-import { statusCommand } from './commands/status.js';
-import { listCommand } from './commands/list.js';
-import { logsCommand } from './commands/logs.js';
-import { replayCommand, restartCommand } from './commands/replay.js';
-import { validateCommand } from './commands/validate.js';
-import { initCommand } from './commands/init.js';
-import { configCommand } from './commands/config.js';
-import { toolsCommand } from './commands/tools.js';
-import { integrationsCommand } from './commands/integrations.js';
-import { templatesCommand } from './commands/templates.js';
-import { templateCommand } from './commands/template/index.js';
-import { projectCommand } from './commands/project.js';
-import { apiStartCommand, apiStopCommand, apiStatusCommand } from './commands/api.js';
-import { installExtensionCommand } from './commands/install.js';
-import { createRegistryCommand } from './commands/registry/index.js';
-import { usersCommand } from './commands/users.js';
-import { ollamaCommand } from './commands/ollama.js';
-import { loadConfig } from './config.js';
-
-const program = new Command();
-
-program
-  .name('studio')
-  .description('Studio v7 — Agentic pipeline orchestrator')
-  .version('0.3.0');
-
-program
-  .command('run <project/pipeline>')
-  .description('Run a pipeline (e.g. studio run cuisine/recipe-generator)')
-  .option('-i, --input <text>', 'Input description for the pipeline')
-  .option('-f, --input-file <path>', 'Path to YAML input file')
-  .option('-r, --repo <path>', 'Path to the target repository')
-  .option('--repo-url <url>', 'Git URL to clone as target repository')
-  .option('--config <path>', 'Path to .studiorc.yaml config file')
-  .option('--provider <name>', 'Override LLM provider for all stages (e.g. mock)')
-  .option('--json', 'Output results as JSON')
-  .option('--verbose', 'Show detailed execution logs')
-  .option('--live', 'Show live per-tool-call spinners during execution')
-  .option('--anonymize', 'Anonymize PII in inputs and outputs before sending to LLM')
-  .action(runCommand);
-
-program
-  .command('status [run-id]')
-  .description('Show status of a pipeline run')
-  .option('--json', 'Output as JSON')
-  .action(statusCommand);
-
-program
-  .command('logs <run-id>')
-  .description('Show log for a pipeline run (from .studio/runs/*.jsonl)')
-  .option('--raw', 'Output raw JSONL lines')
-  .option('--json', 'Output as pretty-printed JSON array')
-  .action(logsCommand);
-
-program
-  .command('replay <run-id>')
-  .description('Replay a past pipeline run from JSONL logs, or re-execute from a specific stage')
-  .option('--verbose', 'Show complete outputs and tool call results')
-  .option('--restart', 'Re-execute pipeline from a specific stage (requires --stage)')
-  .option('--stage <index|name>', 'Stage index (0-based) or name to restart from (use with --restart)')
-  .option('--provider <name>', 'Override LLM provider (e.g. mock) — applies to resumed stages only')
-  .action((runId: string, options: { verbose?: boolean; restart?: boolean; stage?: string; provider?: string }) => {
-    if (options.restart) {
-      if (!options.stage) {
-        console.error(chalk.red('Error: --restart requires --stage <index|name>'));
-        process.exit(1);
-      }
-      return restartCommand(runId, { stage: options.stage, verbose: options.verbose, provider: options.provider });
-    }
-    return replayCommand(runId, options);
-  });
-
-program
-  .command('list <resource>')
-  .description('List projects, pipelines, agents, or runs')
-  .option('--status <status>', 'Filter runs by status')
-  .option('--limit <n>', 'Limit number of results', '10')
-  .option('--project <name>', 'Filter runs by project')
-  .option('--json', 'Output as JSON')
-  .action(listCommand);
-
-program
-  .command('validate <contract> <output>')
-  .description('Validate an output against a contract')
-  .action(validateCommand);
-
-program
-  .command('init [name]')
-  .description('Initialize a new Studio project in the current directory')
-  .option('--template <name>', 'Project template to use (e.g. software)')
-  .option('--project <name>', 'Project name (defaults to directory name or "default")')
-  .option('--provider <name>', 'LLM provider (anthropic, openai) — enables direct mode')
-  .option('--api-key <key>', 'API key for the provider')
-  .option('--force', 'Backup existing .studio/ and reinitialize')
-  .option('--yes', 'Skip confirmation prompts (for CI/CD)')
-  .option('--no-tools', 'Skip tool installation (direct mode only)')
-  .action(initCommand);
-
-program
-  .command('config <action> [args...]')
-  .description('Manage Studio configuration (list, get, set, add-provider)')
-  .option('--api-key <key>', 'API key (used with: config set provider <name> --api-key <key>; config add-provider <name> --api-key <key>)')
-  .option('--set-default', 'Set as default provider (used with: config add-provider)')
-  .action(configCommand);
-
-program
-  .command('tools <action> [args...]')
-  .description('Manage Studio tools (list, add, remove, info)')
-  .action(toolsCommand);
-
-program
-  .command('integrations <action> [args...]')
-  .description('Manage Studio integrations (install, list, remove, test, set)')
-  .action((action: string, args: string[]) => {
-    void integrationsCommand(action, args, {});
-  });
-
-program
-  .command('templates <action> [args...]')
-  .description('Manage Studio templates (list)')
-  .action(templatesCommand);
-
-
-program
-  .command('template <action> [args...]')
-  .description('Template operations (validate)')
-  .action(templateCommand);
-
-program
-  .command('project <action> [args...]')
-  .description('Manage Studio projects (add)')
-  .option('--template <name>', 'Template to use (blank, software, …)')
-  .option('--description <desc>', 'Project description')
-  .action(projectCommand);
-
-program
-  .command('api <action>')
-  .description('Manage the Studio API server (start, stop, status)')
-  .option('--port <port>', 'Port to listen on (default: 3700)')
-  .option('--config <path>', 'Path to config file')
-  .action((action: string, options: { port?: string; config?: string }) => {
-    if (action === 'start') {
-      void apiStartCommand(options);
-    } else if (action === 'stop') {
-      void apiStopCommand();
-    } else if (action === 'status') {
-      void apiStatusCommand(options);
-    } else {
-      console.error(`Unknown api action: ${action}. Use: studio api start|stop|status`);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('install <extension>')
-  .description('Install a Studio extension (api)')
-  .action((extension: string) => {
-    void installExtensionCommand(extension);
-  });
-
-program.addCommand(createRegistryCommand());
-
-const usersCmd = program.command('users').description('Manage users');
-
-usersCmd
-  .command('list')
-  .description('List all users')
-  .action(() => { void usersCommand('list', [], {}); });
-
-usersCmd
-  .command('add <email>')
-  .description('Create a new user')
-  .option('--plan <plan>', 'User plan (free|pro|unlimited)', 'free')
-  .action((email: string, opts: { plan?: string }) => { void usersCommand('add', [email], opts); });
-
-usersCmd
-  .command('remove <email>')
-  .description('Remove a user')
-  .action((email: string) => { void usersCommand('remove', [email], {}); });
-
-usersCmd
-  .command('info <email>')
-  .description("Show user details and today's usage")
-  .action((email: string) => { void usersCommand('info', [email], {}); });
-
-program
-  .command('ollama <action> [model]')
-  .description('Manage local Ollama instance (start, stop, status, pull <model>)')
-  .action(async (action: string, model: string | undefined) => {
-    const config = await loadConfig();
-    const baseUrl = config.providers?.ollama?.baseUrl ?? 'http://localhost:11434';
-    void ollamaCommand(action, model, baseUrl);
-  });
-
-program.parse();

package/src/models-cache.ts

@@ -1,127 +0,0 @@
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24h
-
-interface RawModel {
-  id: string;
-  created?: number;
-  created_at?: string;
-}
-
-interface CacheEntry {
-  models: string[];
-  fetchedAt: number;
-}
-
-const cache = new Map<string, CacheEntry>();
-
-function cacheKey(provider: string, apiKey: string): string {
-  return `${provider}:${apiKey.slice(0, 8)}`;
-}
-
-export function setCachedModels(provider: string, apiKey: string, models: string[]): void {
-  cache.set(cacheKey(provider, apiKey), { models, fetchedAt: Date.now() });
-}
-
-export function getCachedModels(provider: string, apiKey: string): string[] | null {
-  const key = cacheKey(provider, apiKey);
-  const entry = cache.get(key);
-  if (!entry) return null;
-  if (Date.now() - entry.fetchedAt > CACHE_TTL_MS) {
-    cache.delete(key);
-    return null;
-  }
-  return entry.models;
-}
-
-export function filterModels(provider: string, models: RawModel[]): string[] {
-  if (provider === 'anthropic') {
-    return models
-      .filter(
-        (m) =>
-          m.id.startsWith('claude-') &&
-          !m.id.startsWith('claude-instant') &&
-          !m.id.startsWith('claude-2')
-      )
-      .map((m) => m.id);
-  }
-  if (provider === 'openai') {
-    return models
-      .filter(
-        (m) =>
-          m.id.startsWith('gpt-4') ||
-          m.id.startsWith('o1') ||
-          m.id.startsWith('o3')
-      )
-      .map((m) => m.id);
-  }
-  return models.map((m) => m.id);
-}
-
-export function sortModels(modelIds: string[], rawModels: RawModel[]): string[] {
-  const tsMap = new Map<string, number>();
-  for (const m of rawModels) {
-    if (m.created !== undefined) {
-      tsMap.set(m.id, m.created);
-    } else if (m.created_at) {
-      tsMap.set(m.id, new Date(m.created_at).getTime());
-    }
-  }
-  return [...modelIds].sort((a, b) => {
-    const ta = tsMap.get(a) ?? 0;
-    const tb = tsMap.get(b) ?? 0;
-    if (ta !== tb) return tb - ta;
-    return b.localeCompare(a);
-  });
-}
-
-export function parseAndCacheModels(provider: string, apiKey: string, json: unknown): void {
-  try {
-    const data = ((json as Record<string, unknown>).data ?? []) as RawModel[];
-    const filtered = filterModels(provider, data);
-    const sorted = sortModels(filtered, data);
-    setCachedModels(provider, apiKey, sorted);
-  } catch {
-    // ignore malformed responses
-  }
-}
-
-const SUPPORTED_PROVIDERS = new Set(['anthropic', 'openai']);
-
-async function fetchModelsFromProvider(provider: string, apiKey: string): Promise<string[]> {
-  if (!SUPPORTED_PROVIDERS.has(provider)) return [];
-
-  const abort = new AbortController();
-  const timer = setTimeout(() => abort.abort(), 5000);
-
-  try {
-    let url: string;
-    let headers: Record<string, string>;
-
-    if (provider === 'anthropic') {
-      url = 'https://api.anthropic.com/v1/models';
-      headers = { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' };
-    } else {
-      url = 'https://api.openai.com/v1/models';
-      headers = { Authorization: `Bearer ${apiKey}` };
-    }
-
-    const res = await fetch(url, { signal: abort.signal, headers });
-    if (!res.ok) return [];
-
-    const json = await res.json();
-    const data = ((json as Record<string, unknown>).data ?? []) as RawModel[];
-    const filtered = filterModels(provider, data);
-    const sorted = sortModels(filtered, data);
-    setCachedModels(provider, apiKey, sorted);
-    return sorted;
-  } catch {
-    return [];
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export async function getAvailableModels(provider: string, apiKey: string): Promise<string[]> {
-  const cached = getCachedModels(provider, apiKey);
-  if (cached !== null) return cached;
-  return fetchModelsFromProvider(provider, apiKey);
-}

package/src/output/file-changes.ts

@@ -1,97 +0,0 @@
-import { execSync } from 'node:child_process';
-import { join } from 'node:path';
-import chalk from 'chalk';
-import type { ToolCallCompleteEvent } from '@studio-foundation/contracts';
-
-export interface FileChange {
-  path: string;
-  status: 'M' | 'A';
-  added: number;
-  removed: number;
-}
-
-export class FileChangeCollector {
-  private paths = new Set<string>();
-
-  onToolCallComplete(event: ToolCallCompleteEvent): void {
-    if (event.tool !== 'repo_manager-write_file') return;
-    if (event.error) return;
-
-    const result = event.result as { path?: string } | undefined;
-    if (result?.path) {
-      this.paths.add(result.path);
-    }
-  }
-
-  getWrittenPaths(): string[] {
-    return [...this.paths];
-  }
-
-  computeSummary(repoPath: string): FileChange[] | null {
-    const written = this.getWrittenPaths();
-    if (written.length === 0) return null;
-
-    try {
-      const diffOutput = execSync(
-        `git diff --numstat -- ${written.map((p) => JSON.stringify(p)).join(' ')}`,
-        { cwd: repoPath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
-      ).trim();
-
-      const diffMap = new Map<string, { added: number; removed: number }>();
-      if (diffOutput) {
-        for (const line of diffOutput.split('\n')) {
-          const [addedStr, removedStr, ...pathParts] = line.split('\t');
-          const filePath = pathParts.join('\t');
-          diffMap.set(filePath, {
-            added: parseInt(addedStr, 10) || 0,
-            removed: parseInt(removedStr, 10) || 0,
-          });
-        }
-      }
-
-      const changes: FileChange[] = [];
-      for (const filePath of written) {
-        const diff = diffMap.get(filePath);
-        if (diff) {
-          changes.push({ path: filePath, status: 'M', added: diff.added, removed: diff.removed });
-        } else {
-          let lineCount = 0;
-          try {
-            const wcOutput = execSync(
-              `wc -l < ${JSON.stringify(join(repoPath, filePath))}`,
-              { cwd: repoPath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
-            ).trim();
-            lineCount = parseInt(wcOutput, 10) || 0;
-          } catch {
-            // File might have been deleted or moved — skip line count
-          }
-          changes.push({ path: filePath, status: 'A', added: lineCount, removed: 0 });
-        }
-      }
-
-      return changes;
-    } catch {
-      // git not available or not a git repo — graceful degradation
-      return null;
-    }
-  }
-}
-
-export function formatFileChanges(changes: FileChange[]): string {
-  if (changes.length === 0) return '';
-
-  const lines: string[] = ['', 'Changes:'];
-  for (const change of changes) {
-    const tag = change.status === 'A'
-      ? chalk.green('A')
-      : chalk.yellow('M');
-
-    const detail = change.status === 'A'
-      ? chalk.gray(`(new file, ${change.added} lines)`)
-      : chalk.gray(`(+${change.added} -${change.removed})`);
-
-    lines.push(`  ${tag} ${change.path}  ${detail}`);
-  }
-
-  return lines.join('\n');
-}

package/src/output/formatter.ts

@@ -1,85 +0,0 @@
-import chalk from 'chalk';
-import type { PipelineRun } from '@studio-foundation/contracts';
-
-export function formatResult(run: PipelineRun): void {
-  console.log('');
-  console.log(`Pipeline: ${chalk.bold(run.pipeline_name)}`);
-
-  if (run.status === 'success') {
-    console.log(`Status:   ${chalk.green('✓ success')}`);
-  } else if (run.status === 'rejected') {
-    console.log(`Status:   ${chalk.red('✗ rejected by QA')}`);
-  } else {
-    console.log(`Status:   ${chalk.red('✗ failed')}`);
-  }
-
-  if (run.started_at && run.completed_at) {
-    const duration = formatDuration(
-      new Date(run.completed_at).getTime() - new Date(run.started_at).getTime()
-    );
-    console.log(`Duration: ${duration}`);
-  }
-
-  if (run.stages.length > 0) {
-    console.log('');
-    console.log('Stages:');
-    const total = run.stages.length;
-
-    for (let i = 0; i < run.stages.length; i++) {
-      const stage = run.stages[i];
-      const index = `[${i + 1}/${total}]`;
-      const name = stage.stage_name;
-      const attempts = stage.tasks[0]?.agent_runs.length ?? 0;
-
-      const dots = '.'.repeat(Math.max(2, 30 - name.length));
-
-      if (stage.status === 'success') {
-        console.log(
-          `  ${index} ${name} ${chalk.gray(dots)} ${chalk.green('✓')} (${attempts} attempt${attempts !== 1 ? 's' : ''})`
-        );
-      } else if (stage.status === 'rejected') {
-        console.log(
-          `  ${index} ${name} ${chalk.gray(dots)} ${chalk.red('✗ REJECTED')}`
-        );
-      } else if (stage.status === 'failed') {
-        console.log(
-          `  ${index} ${name} ${chalk.gray(dots)} ${chalk.red('✗ FAILED')} (${attempts} attempts exhausted)`
-        );
-        // Show errors from the last agent run
-        const lastAgentRun = stage.tasks[0]?.agent_runs.at(-1);
-        if (lastAgentRun?.error) {
-          console.log(`${chalk.gray('        Errors:')}`);
-          console.log(`${chalk.gray('        -')} ${lastAgentRun.error}`);
-        }
-      } else if (stage.status === 'skipped') {
-        const reasonText = stage.skipped_reason ? ` (skipped: ${stage.skipped_reason})` : '';
-        console.log(
-          `  ${index} ${name} ${chalk.gray(dots)} ${chalk.dim('⊘ skipped')}${chalk.gray(reasonText)}`
-        );
-      } else {
-        console.log(
-          `  ${index} ${name} ${chalk.gray(dots)} ${chalk.yellow(stage.status)}`
-        );
-      }
-    }
-  }
-
-  console.log('');
-}
-
-export function formatJson(data: unknown): void {
-  console.log(JSON.stringify(data, null, 2));
-}
-
-export function formatError(error: Error): void {
-  console.error(chalk.red(`Error: ${error.message}`));
-}
-
-export function formatDuration(ms: number): string {
-  if (ms < 1000) return `${ms}ms`;
-  const seconds = Math.floor(ms / 1000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  return `${minutes}m${remainingSeconds.toString().padStart(2, '0')}s`;
-}