@studio-foundation/cli 0.3.0-beta.1

package/src/commands/ollama.ts

@@ -0,0 +1,168 @@
+import { spawnSync } from 'node:child_process';
+import chalk from 'chalk';
+
+const OLLAMA_DOCKER_IMAGE = 'ollama/ollama';
+
+function formatBytes(bytes: number): string {
+  const gb = bytes / (1024 ** 3);
+  return gb >= 1 ? `${gb.toFixed(1)} GB` : `${(bytes / (1024 ** 2)).toFixed(0)} MB`;
+}
+
+async function isOllamaRunning(baseUrl: string): Promise<false | { models: Array<{ name: string; size: number }> }> {
+  try {
+    const res = await fetch(`${baseUrl}/api/tags`);
+    if (!res.ok) return false;
+    const data = await res.json() as { models?: Array<{ name: string; size: number }> };
+    return { models: data.models ?? [] };
+  } catch {
+    return false;
+  }
+}
+
+export async function ollamaStatusCommand(baseUrl: string): Promise<void> {
+  const result = await isOllamaRunning(baseUrl);
+  if (!result) {
+    console.log(chalk.red('  ✗ Ollama not running'));
+    console.log('');
+    console.log('To start Ollama:');
+    console.log(`  ${chalk.cyan('ollama serve')}                              # native`);
+    console.log(`  ${chalk.cyan(`docker run -d -p 11434:11434 ${OLLAMA_DOCKER_IMAGE}`)}   # Docker`);
+    return;
+  }
+  console.log(chalk.green(`  ✓ Ollama running at ${baseUrl}`));
+  if (result.models.length === 0) {
+    console.log('  No models pulled yet. Run: studio ollama pull llama3.3');
+  } else {
+    console.log('');
+    console.log('  Pulled models:');
+    for (const model of result.models) {
+      console.log(`    ${chalk.bold(model.name.padEnd(30))} ${formatBytes(model.size)}`);
+    }
+  }
+}
+
+export async function ollamaStartCommand(baseUrl: string): Promise<void> {
+  const running = await isOllamaRunning(baseUrl);
+  if (running) {
+    console.log(chalk.green(`  ✓ Ollama already running at ${baseUrl}`));
+    return;
+  }
+
+  const hasNative = spawnSync('ollama', ['--version'], { stdio: 'ignore' }).status === 0;
+  if (hasNative) {
+    console.log('Ollama is installed but not running. Start it with:');
+    console.log('');
+    console.log(`  ${chalk.cyan('ollama serve')}`);
+    return;
+  }
+
+  const hasDocker = spawnSync('docker', ['--version'], { stdio: 'ignore' }).status === 0;
+  if (hasDocker) {
+    console.log('Docker is available. Start Ollama with:');
+    console.log('');
+    console.log(`  ${chalk.cyan(`docker run -d -p 11434:11434 --name ollama ${OLLAMA_DOCKER_IMAGE}`)}`);
+    console.log('');
+    console.log('Then pull a model:');
+    console.log(`  ${chalk.cyan('studio ollama pull llama3.3')}`);
+    return;
+  }
+
+  console.log(chalk.yellow('  Neither Ollama nor Docker found.'));
+  console.log('');
+  console.log('Options:');
+  console.log(`  Install Ollama natively: ${chalk.cyan('https://ollama.com')}`);
+  console.log(`  Install Docker:          ${chalk.cyan('https://docker.com')}`);
+}
+
+export async function ollamaStopCommand(): Promise<void> {
+  console.log('To stop Ollama:');
+  console.log('');
+  console.log(`  Native:  ${chalk.cyan('Ctrl+C')} in the terminal running ${chalk.cyan('ollama serve')}`);
+  console.log(`  Docker:  ${chalk.cyan('docker stop ollama')}`);
+}
+
+export async function ollamaPullCommand(model: string, baseUrl: string): Promise<void> {
+  const running = await isOllamaRunning(baseUrl);
+  if (!running) {
+    console.error(chalk.red(`  ✗ Ollama not running at ${baseUrl}`));
+    console.error(`  Run: ${chalk.cyan('studio ollama start')}`);
+    process.exit(1);
+  }
+
+  process.stdout.write(`Pulling ${chalk.bold(model)}...`);
+
+  try {
+    const res = await fetch(`${baseUrl}/api/pull`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model, stream: true }),
+    });
+
+    if (!res.ok || !res.body) {
+      process.stdout.write('\n');
+      console.error(`Pull failed: HTTP ${res.status}`);
+      process.exit(1);
+    }
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let lastStatus = '';
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const event = JSON.parse(trimmed) as { status?: string; error?: string };
+          if (event.error) {
+            process.stdout.write('\n');
+            console.error(chalk.red(`  ✗ ${event.error}`));
+            process.exit(1);
+          }
+          if (event.status && event.status !== lastStatus) {
+            process.stdout.write(`\r${event.status.padEnd(60)}`);
+            lastStatus = event.status;
+          }
+        } catch {
+          // ignore non-JSON lines
+        }
+      }
+    }
+
+    process.stdout.write('\n');
+    console.log(chalk.green(`  ✓ Pulled ${model}`));
+  } catch (err) {
+    process.stdout.write('\n');
+    console.error(chalk.red(`  ✗ Pull failed: ${err instanceof Error ? err.message : String(err)}`));
+    console.error(`  You can retry with: ${chalk.cyan(`studio ollama pull ${model}`)}`);
+    process.exit(1);
+  }
+}
+
+export async function ollamaCommand(action: string, modelArg: string | undefined, baseUrl: string): Promise<void> {
+  if (action === 'status') {
+    await ollamaStatusCommand(baseUrl);
+  } else if (action === 'start') {
+    await ollamaStartCommand(baseUrl);
+  } else if (action === 'stop') {
+    await ollamaStopCommand();
+  } else if (action === 'pull') {
+    if (!modelArg) {
+      console.error('Usage: studio ollama pull <model>');
+      console.error('Example: studio ollama pull llama3.3');
+      process.exit(1);
+    }
+    await ollamaPullCommand(modelArg, baseUrl);
+  } else {
+    console.error(`Unknown ollama action: ${action}. Use: studio ollama start|stop|status|pull <model>`);
+    process.exit(1);
+  }
+}

package/src/commands/project.ts

@@ -0,0 +1,167 @@
+import { mkdir, access, cp } from 'node:fs/promises';
+import { resolve, join, relative, sep } from 'node:path';
+import chalk from 'chalk';
+import { input, select } from '@inquirer/prompts';
+import { listTemplates } from './templates.js';
+
+const TEMPLATES_DIR = resolve(import.meta.dirname, '../../templates');
+
+export const PROJECT_SUBDIRS = ['pipelines', 'agents', 'contracts', 'tools', 'inputs'];
+
+/**
+ * Create a project directory under .studio/projects/.
+ * Throws if the project already exists or the template is not found.
+ *
+ * @deprecated The flat .studio/ structure no longer uses projects/ subdirs.
+ * This function is kept for backward compatibility but will be removed.
+ */
+export async function createProjectDir(
+  projectsDir: string,
+  projectName: string,
+  templateName?: string,
+  options?: { withTools?: boolean }
+): Promise<void> {
+  const withTools = options?.withTools ?? true;
+  const projectDir = join(projectsDir, projectName);
+
+  // Check if already exists
+  const alreadyExists = await access(projectDir).then(() => true).catch(() => false);
+  if (alreadyExists) {
+    throw new Error(`Project '${projectName}' already exists in ${projectsDir}`);
+  }
+
+  if (templateName) {
+    const templateDir = resolve(TEMPLATES_DIR, 'projects', templateName);
+    const templateExists = await access(templateDir).then(() => true).catch(() => false);
+    if (!templateExists) {
+      throw new Error(
+        `Template '${templateName}' not found. Run 'studio templates list' to see available templates.`
+      );
+    }
+
+    await mkdir(projectDir, { recursive: true });
+    if (withTools) {
+      await cp(templateDir, projectDir, {
+        recursive: true,
+        filter: (src) => !src.endsWith('metadata.json'),
+      });
+    } else {
+      await cp(templateDir, projectDir, {
+        recursive: true,
+        filter: (src) => {
+          const rel = relative(templateDir, src);
+          return !rel.endsWith('metadata.json') && rel !== 'tools' && !rel.startsWith('tools' + sep);
+        },
+      });
+      await mkdir(join(projectDir, 'tools'), { recursive: true });
+    }
+  } else {
+    for (const sub of PROJECT_SUBDIRS) {
+      await mkdir(join(projectDir, sub), { recursive: true });
+    }
+  }
+}
+
+/**
+ * Validate a project name: lowercase alphanumeric + hyphens, no leading/trailing hyphens.
+ * Returns true if valid, or an error string if not.
+ */
+export function validateProjectName(name: string): true | string {
+  if (/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(name)) {
+    return true;
+  }
+  return 'Project name must be lowercase alphanumeric with hyphens (e.g. my-project)';
+}
+
+/**
+ * Non-interactive project creation.
+ * Validates name, then delegates to createProjectDir.
+ *
+ * @deprecated Use studio init in a new directory instead.
+ */
+export async function projectAddDirect(
+  studioDir: string,
+  projectName: string,
+  templateName?: string,
+  _description?: string
+): Promise<void> {
+  const validation = validateProjectName(projectName);
+  if (validation !== true) {
+    throw new Error(validation);
+  }
+  const projectsDir = join(studioDir, 'projects');
+  await createProjectDir(projectsDir, projectName, templateName);
+}
+
+/**
+ * Interactive wizard for adding a project to an existing workspace.
+ *
+ * @deprecated Use studio init in a new directory instead.
+ */
+export async function projectAddWizard(studioDir: string): Promise<void> {
+  // Step 1: Project name
+  const rawName = await input({
+    message: 'Project name:',
+    validate: (value: string) => {
+      const trimmed = value.trim();
+      if (!trimmed) return 'Project name is required';
+      const v = validateProjectName(trimmed);
+      return v === true ? true : v;
+    },
+  });
+  const projectName = rawName.trim();
+
+  // Step 2: Description (optional, not persisted)
+  await input({
+    message: 'Description (optional, press Enter to skip):',
+  });
+
+  // Step 3: Template
+  const templates = await listTemplates();
+  const templateChoices = templates.map((t) => ({
+    value: t.name,
+    name: `${t.name} — ${t.description}`,
+  }));
+
+  const templateName = await select({
+    message: 'Choose a template:',
+    choices: templateChoices,
+  });
+
+  // Step 4: Create
+  console.log('');
+  const projectsDir = join(studioDir, 'projects');
+  await projectAddDirect(studioDir, projectName, templateName);
+
+  // Step 5: Success output
+  for (const sub of PROJECT_SUBDIRS) {
+    console.log(chalk.green(`  ✓ ${join(projectsDir, projectName, sub).replace(process.cwd() + '/', '')}/`));
+  }
+  console.log('');
+
+  // Step 6: Next steps
+  const selectedTemplate = templates.find((t) => t.name === templateName);
+  const firstPipeline = selectedTemplate?.pipelines?.[0] ?? 'your-pipeline';
+  console.log(chalk.bold('Done! Run your first pipeline:'));
+  console.log(`  ${chalk.cyan(`studio run ${projectName}/${firstPipeline} --input "..."`)}`);
+  console.log('');
+}
+
+/**
+ * CLI dispatcher for `studio project <action> [args...]`.
+ * This command is deprecated — the flat .studio/ structure no longer uses projects/ subdirs.
+ */
+export async function projectCommand(
+  _action: string,
+  _args: string[],
+  _options: { template?: string; description?: string }
+): Promise<void> {
+  console.error(
+    chalk.red('  ✗ `studio project add` is no longer supported.')
+  );
+  console.log('');
+  console.log('Each workspace now has one flat .studio/ structure.');
+  console.log(`To start a new project, create a new directory and run ${chalk.cyan('studio init')}.`);
+  console.log('');
+  process.exit(1);
+}

package/src/commands/registry/audit.ts

@@ -0,0 +1,87 @@
+import chalk from 'chalk';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { RegistryLockfile } from '../../registry/lockfile.js';
+import { findStudioDir } from '../../studio-dir.js';
+import { INSTALL_DIRS } from '../../registry/types.js';
+import type { PackageType } from '../../registry/types.js';
+
+interface AuditResult {
+  name: string;
+  ok: boolean;
+  status: 'ok' | 'tampered' | 'missing';
+}
+
+const FILE_EXTENSIONS: Partial<Record<PackageType, string>> = {
+  tool: '.tool.yaml',
+  pipeline: '.pipeline.yaml',
+  integration: '.integration.yaml',
+  agent: '.agent.yaml',
+  skill: '.skill.md',
+};
+
+interface AuditOptions {
+  studioDir?: string;
+  cwd?: string;
+}
+
+export async function auditPackages(options: AuditOptions = {}): Promise<AuditResult[]> {
+  const studioDir = options.studioDir ??
+    (await findStudioDir(options.cwd ?? process.cwd()) ?? resolve(process.cwd(), '.studio'));
+  const lockfile = new RegistryLockfile(studioDir);
+  const installed = await lockfile.list();
+  const results: AuditResult[] = [];
+
+  for (const entry of installed) {
+    const type = entry.type as PackageType;
+    const destDir = resolve(studioDir, INSTALL_DIRS[type]);
+
+    if (type === 'template' || type === 'plugin') {
+      // Directory packages: skip SHA check (would need to hash the full tree)
+      results.push({ name: entry.name, ok: true, status: 'ok' });
+      continue;
+    }
+
+    const ext = FILE_EXTENSIONS[type] ?? '.yaml';
+    const filePath = resolve(destDir, `${entry.name}${ext}`);
+
+    if (!existsSync(filePath)) {
+      results.push({ name: entry.name, ok: false, status: 'missing' });
+      continue;
+    }
+
+    const content = await readFile(filePath, 'utf8');
+    const actual = createHash('sha256').update(content).digest('hex');
+    const ok = actual === entry.sha256;
+    results.push({ name: entry.name, ok, status: ok ? 'ok' : 'tampered' });
+  }
+
+  return results;
+}
+
+export async function auditCommand(): Promise<void> {
+  const results = await auditPackages();
+
+  if (results.length === 0) {
+    console.log(chalk.gray('No packages installed.'));
+    return;
+  }
+
+  let hasIssues = false;
+  for (const r of results) {
+    if (r.ok) {
+      console.log(chalk.green(`  ✓ ${r.name}`));
+    } else {
+      hasIssues = true;
+      const label = r.status === 'missing' ? chalk.red('MISSING') : chalk.red('TAMPERED');
+      console.log(`  ✗ ${r.name} — ${label}`);
+    }
+  }
+
+  if (hasIssues) {
+    console.log(chalk.yellow('\nRun: studio registry update <name> to reinstall affected packages'));
+    process.exit(1);
+  }
+}

package/src/commands/registry/index.ts

@@ -0,0 +1,63 @@
+import { Command } from 'commander';
+import { searchCommand, browseCommand } from './search.js';
+import { installCommand } from './install.js';
+import { removeCommand } from './remove.js';
+import { updateCommand, outdatedCommand } from './update.js';
+import { publishCommand } from './publish.js';
+import { auditCommand } from './audit.js';
+import { syncRegistry } from './sync.js';
+
+export function createRegistryCommand(): Command {
+  const registry = new Command('registry')
+    .description('Manage community registry packages');
+
+  registry
+    .command('search <query>')
+    .description('Search packages in the registry')
+    .option('--type <type>', 'Filter by type: tool, template, pipeline, integration, agent, plugin, skill')
+    .action((query: string, options: { type?: string }) => searchCommand(query, options));
+
+  registry
+    .command('browse')
+    .description('Browse most popular packages')
+    .action(() => browseCommand());
+
+  registry
+    .command('install <name>')
+    .description('Install a package (use name@version for a specific version)')
+    .option('--force', 'Reinstall even if already installed')
+    .action((name: string, options: { force?: boolean }) => installCommand(name, options));
+
+  registry
+    .command('remove <name>')
+    .description('Uninstall a package')
+    .action((name: string) => removeCommand(name));
+
+  registry
+    .command('update <name>')
+    .description('Update an installed package to latest')
+    .action((name: string) => updateCommand(name));
+
+  registry
+    .command('outdated')
+    .description('List packages with available updates')
+    .action(() => outdatedCommand());
+
+  registry
+    .command('publish <path>')
+    .description('Publish a package to the community registry via GitHub PR')
+    .option('--dry-run', 'Validate only, do not create PR')
+    .action((path: string, options: { dryRun?: boolean }) => publishCommand(path, options));
+
+  registry
+    .command('audit')
+    .description('Verify SHA256 integrity of installed packages')
+    .action(() => auditCommand());
+
+  registry
+    .command('sync')
+    .description('Force refresh the registry index cache')
+    .action(() => syncRegistry({ force: true }));
+
+  return registry;
+}