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

package/src/registry/lockfile.ts

@@ -1,68 +0,0 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import type { Lockfile, LockfileEntry } from './types.js';
-
-export class RegistryLockfile {
-  private lockPath: string;
-  private studioDir: string;
-
-  constructor(studioDir: string) {
-    this.studioDir = studioDir;
-    this.lockPath = resolve(studioDir, 'registry.lock.json');
-  }
-
-  async read(): Promise<Lockfile> {
-    try {
-      const raw = await readFile(this.lockPath, 'utf8');
-      return JSON.parse(raw) as Lockfile;
-    } catch {
-      return { installed: {} };
-    }
-  }
-
-  private async write(data: Lockfile): Promise<void> {
-    await mkdir(this.studioDir, { recursive: true });
-    await writeFile(this.lockPath, JSON.stringify(data, null, 2) + '\n');
-  }
-
-  async add(name: string, entry: LockfileEntry): Promise<void> {
-    const data = await this.read();
-    data.installed[name] = entry;
-    await this.write(data);
-  }
-
-  async remove(name: string): Promise<void> {
-    const data = await this.read();
-    delete data.installed[name];
-    await this.write(data);
-  }
-
-  async get(name: string): Promise<LockfileEntry | null> {
-    const data = await this.read();
-    return data.installed[name] ?? null;
-  }
-
-  async list(): Promise<Array<{ name: string } & LockfileEntry>> {
-    const data = await this.read();
-    return Object.entries(data.installed).map(([name, entry]) => ({ name, ...entry }));
-  }
-
-  async addRequiredBy(name: string, requiredBy: string): Promise<void> {
-    const data = await this.read();
-    const entry = data.installed[name];
-    if (!entry) return;
-    const existing = entry.required_by ?? [];
-    if (!existing.includes(requiredBy)) {
-      data.installed[name] = { ...entry, required_by: [...existing, requiredBy] };
-      await this.write(data);
-    }
-  }
-
-  async removeRequiredBy(name: string, requiredBy: string): Promise<void> {
-    const data = await this.read();
-    const entry = data.installed[name];
-    if (!entry) return;
-    data.installed[name] = { ...entry, required_by: (entry.required_by ?? []).filter(r => r !== requiredBy) };
-    await this.write(data);
-  }
-}

package/src/registry/resolver.ts

@@ -1,113 +0,0 @@
-import type { PackageMetadata, PackageType, RegistryIndex, Lockfile, PackageDependencies } from './types.js';
-
-export interface DependencyNode {
-  name: string;
-  type: PackageType;
-}
-
-export interface ResolvedGraph {
-  required: DependencyNode[];
-  recommended: DependencyNode[];
-}
-
-type MetadataFetcher = (name: string) => Promise<PackageMetadata>;
-
-/** Extract all dependency names (regardless of whether they're in the index) for cycle detection. */
-function depNames(deps: PackageDependencies, kind: 'required' | 'recommended'): string[] {
-  const names: string[] = [];
-  for (const [, spec] of Object.entries(deps)) {
-    const arr: string[] = (spec as Record<string, string[]>)[kind] ?? [];
-    names.push(...arr);
-  }
-  return names;
-}
-
-function flattenDeps(
-  deps: PackageDependencies,
-  kind: 'required' | 'recommended',
-  index: RegistryIndex,
-): DependencyNode[] {
-  const nodes: DependencyNode[] = [];
-  for (const [, spec] of Object.entries(deps)) {
-    const names: string[] = (spec as Record<string, string[]>)[kind] ?? [];
-    for (const name of names) {
-      const entry = index.packages.find(p => p.name === name);
-      if (entry) {
-        nodes.push({ name, type: entry.type as PackageType });
-      }
-    }
-  }
-  return nodes;
-}
-
-export async function resolveDependencies(
-  rootPackageName: string,
-  meta: PackageMetadata,
-  index: RegistryIndex,
-  _lockfile: Lockfile,
-  fetchMeta: MetadataFetcher,
-): Promise<ResolvedGraph> {
-  const resolved = new Map<string, DependencyNode>();
-  const visiting = new Set<string>();
-
-  // Track the root package so cycles back to it are detected
-  visiting.add(rootPackageName);
-
-  async function visit(name: string, pkgMeta: PackageMetadata): Promise<void> {
-    if (visiting.has(name)) {
-      throw new Error(`Circular dependency detected: ${name} is part of a cycle`);
-    }
-    if (resolved.has(name)) return;
-
-    visiting.add(name);
-
-    if (pkgMeta.dependencies) {
-      // Check for cycles on all required names (even those not in index)
-      for (const depName of depNames(pkgMeta.dependencies, 'required')) {
-        if (visiting.has(depName)) {
-          throw new Error(`Circular dependency detected: ${depName} is part of a cycle`);
-        }
-      }
-
-      const requiredNodes = flattenDeps(pkgMeta.dependencies, 'required', index);
-      for (const node of requiredNodes) {
-        if (!resolved.has(node.name)) {
-          const subMeta = await fetchMeta(node.name);
-          await visit(node.name, subMeta);
-          if (!resolved.has(node.name)) {
-            resolved.set(node.name, node);
-          }
-        }
-      }
-    }
-
-    visiting.delete(name);
-  }
-
-  if (meta.dependencies) {
-    // Check for cycles at the first level too (root → dep that cycles back to root)
-    for (const depName of depNames(meta.dependencies, 'required')) {
-      if (visiting.has(depName)) {
-        throw new Error(`Circular dependency detected: ${depName} is part of a cycle`);
-      }
-    }
-
-    const firstLevelRequired = flattenDeps(meta.dependencies, 'required', index);
-    for (const node of firstLevelRequired) {
-      const subMeta = await fetchMeta(node.name);
-      await visit(node.name, subMeta);
-      if (!resolved.has(node.name)) {
-        resolved.set(node.name, node);
-      }
-    }
-  }
-
-  const recommended: DependencyNode[] = meta.dependencies
-    ? flattenDeps(meta.dependencies, 'recommended', index)
-    : [];
-
-  return {
-    required: Array.from(resolved.values()),
-    recommended,
-  };
-}

package/src/registry/types.ts

@@ -1,66 +0,0 @@
-export type PackageType =
-  | 'tool'
-  | 'template'
-  | 'pipeline'
-  | 'integration'
-  | 'agent'
-  | 'plugin'
-  | 'skill';
-
-export interface PackageEntry {
-  name: string;
-  type: PackageType;
-  version: string;
-  description: string;
-  author: string;
-  license: string;
-  tags: string[];
-  studio_version: string | null;
-  downloads: number;
-}
-
-export interface RegistryIndex {
-  generated_at: string;
-  version: string;
-  packages: PackageEntry[];
-}
-
-export interface PackageDependencies {
-  tools?:     { required?: string[]; recommended?: string[] };
-  agents?:    { required?: string[]; recommended?: string[] };
-  skills?:    { required?: string[]; recommended?: string[] };
-  templates?: { required?: string[]; recommended?: string[] };
-  pipelines?: { required?: string[]; recommended?: string[] };
-}
-
-export interface PackageMetadata extends PackageEntry {
-  requires_binaries?: string[];
-  dependencies?: PackageDependencies;
-}
-
-export interface LockfileEntry {
-  version: string;
-  type: PackageType;
-  installed_at: string;
-  sha256: string;
-  required_by?: string[];
-}
-
-export interface Lockfile {
-  installed: Record<string, LockfileEntry>;
-}
-
-/** Where packages get installed relative to the project's .studio/ dir */
-export const INSTALL_DIRS: Record<PackageType, string> = {
-  tool: 'tools',
-  template: 'projects',
-  pipeline: 'pipelines',
-  integration: 'integrations',
-  agent: 'agents',
-  plugin: 'plugins',
-  skill: 'skills',
-};
-
-export const REGISTRY_REPO = 'PipStudio/studio-community';
-export const REGISTRY_RAW_BASE = `https://raw.githubusercontent.com/${REGISTRY_REPO}/main`;
-export const REGISTRY_API_BASE = `https://api.github.com/repos/${REGISTRY_REPO}`;

package/src/run-logger.ts

@@ -1,66 +0,0 @@
-import { createWriteStream, mkdirSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-const RUNS_DIR = '.studio/runs';
-
-function runIdShort(runId: string): string {
-  return runId.slice(0, 8);
-}
-
-function dateForFilename(): string {
-  const iso = new Date().toISOString();
-  return iso.slice(0, 16).replace(/(\d{2}):(\d{2})$/, '$1h$2m');
-}
-
-export interface RunLogger {
-  start(runId: string, pipeline: string): void;
-  log(payload: Record<string, unknown>): void;
-  close(): Promise<void>;
-  getLogPath(): string;
-}
-
-export function createRunLogger(cwd: string = process.cwd()): RunLogger {
-  let logPath = '';
-  let stream: ReturnType<typeof createWriteStream> | null = null;
-  let shortRunId = '';
-
-  return {
-    start(runId: string, pipeline: string): void {
-      shortRunId = runIdShort(runId);
-      const date = dateForFilename();
-      const base = resolve(cwd, RUNS_DIR);
-      logPath = resolve(base, `${date}-${pipeline}-${shortRunId}.jsonl`);
-      mkdirSync(base, { recursive: true });
-      stream = createWriteStream(logPath, { flags: 'a' });
-    },
-
-    log(payload: Record<string, unknown>): void {
-      const line: Record<string, unknown> = {
-        ts: new Date().toISOString(),
-        ...payload,
-        run_id: payload.run_id !== undefined ? runIdShort(String(payload.run_id)) : shortRunId,
-      };
-      const out = JSON.stringify(line) + '\n';
-      if (stream?.writable) {
-        stream.write(out);
-      }
-    },
-
-    close(): Promise<void> {
-      return new Promise((resolve) => {
-        if (stream) {
-          stream.end(() => {
-            stream = null;
-            resolve();
-          });
-        } else {
-          resolve();
-        }
-      });
-    },
-
-    getLogPath(): string {
-      return logPath;
-    },
-  };
-}

package/src/run-store-factory.ts

@@ -1,30 +0,0 @@
-import { join } from 'node:path';
-import { mkdirSync } from 'node:fs';
-import type { StudioConfig } from './config.js';
-import { SQLiteRunStore, InMemoryRunStore, PgRunStore } from '@studio-foundation/engine';
-import type { AnyRunStore } from '@studio-foundation/engine';
-
-/**
- * Create the production RunStore from config.
- * Returns AnyRunStore (sync RunStore or async AsyncRunStore) based on config.db.type.
- * Defaults to SQLite when no db config is present.
- */
-export async function createRunStore(config: StudioConfig): Promise<AnyRunStore> {
-  const dbType = config.db?.type ?? 'sqlite';
-
-  if (dbType === 'inmemory') {
-    return new InMemoryRunStore();
-  }
-
-  if (dbType === 'postgres') {
-    const url = config.db?.url;
-    if (!url) throw new Error('db.url is required when db.type is postgres');
-    return new PgRunStore(url);
-  }
-
-  // Default: sqlite
-  const studioDir = config.resolvedStudioDir ?? join(process.cwd(), '.studio');
-  mkdirSync(join(studioDir, 'runs'), { recursive: true });
-  const dbPath = join(studioDir, 'runs', 'runs.db');
-  return new SQLiteRunStore(dbPath);
-}

package/src/studio-dir.ts

@@ -1,28 +0,0 @@
-import { access } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-
-/**
- * Walk up the directory tree from `startDir` looking for a `.studio/` directory.
- * Like git looking for `.git/`.
- * Returns the absolute path to `.studio/`, or null if not found.
- */
-export async function findStudioDir(startDir: string): Promise<string | null> {
-  let current = resolve(startDir);
-
-  while (true) {
-    const candidate = join(current, '.studio');
-    try {
-      await access(candidate);
-      return candidate;
-    } catch {
-      // not found here, go up
-    }
-
-    const parent = dirname(current);
-    if (parent === current) {
-      // Reached filesystem root
-      return null;
-    }
-    current = parent;
-  }
-}

package/src/utils/input-wizard.ts

@@ -1,73 +0,0 @@
-import { input } from '@inquirer/prompts';
-import type { InputSchema } from '@studio-foundation/contracts';
-
-export function validateInputSchema(raw: unknown): InputSchema {
-  const schema = raw as Record<string, unknown>;
-
-  if (!Array.isArray(schema?.fields) || schema.fields.length === 0) {
-    throw new Error('input_schema must have at least one field');
-  }
-
-  for (const field of schema.fields as any[]) {
-    const name = field.name ?? '(unnamed)';
-
-    if (!field.prompt || typeof field.prompt !== 'string' || !field.prompt.trim()) {
-      throw new Error(`Field '${name}' must have a non-empty 'prompt'`);
-    }
-
-    if (field.type !== 'text' && field.type !== 'array') {
-      throw new Error(
-        `Field '${name}' has invalid type '${field.type}'. Must be 'text' or 'array'`
-      );
-    }
-
-    if (field.type === 'array' && field.items !== 'text') {
-      throw new Error(`Array field '${name}' must have items: 'text'`);
-    }
-  }
-
-  return raw as InputSchema;
-}
-
-export async function collectStructuredInput(
-  schema: InputSchema
-): Promise<Record<string, unknown>> {
-  const result: Record<string, unknown> = {};
-
-  for (const field of schema.fields) {
-    if (field.type === 'text') {
-      result[field.name] = await input({
-        message: field.prompt,
-        required: field.required,
-        default: field.default,
-      });
-    } else if (field.type === 'array') {
-      const items: string[] = [];
-      let index = 1;
-
-      while (true) {
-        const value = await input({
-          message: `${field.prompt} (${index})`,
-          required: index === 1 && field.required,
-          default: '',
-        });
-
-        if (value === '') {
-          if (index === 1 && field.required) {
-            console.log('At least one value required.');
-            continue;
-          }
-          break;
-        }
-
-        items.push(value);
-        index++;
-      }
-
-      result[field.name] = items;
-    }
-  }
-
-  console.log('\n✓ Input collected\n');
-  return result;
-}

package/src/utils/placeholders.ts

@@ -1,10 +0,0 @@
-/**
- * Replace {{ALL_CAPS}} placeholders in `content` with values from `vars`.
- * Throws if any placeholder has no corresponding entry in `vars`.
- */
-export function applyPlaceholders(content: string, vars: Record<string, string>): string {
-  return content.replace(/\{\{([A-Z][A-Z0-9_]*)\}\}/g, (match, key) => {
-    if (key in vars) return vars[key];
-    throw new Error(`Unresolved placeholder: ${match}`);
-  });
-}

package/tests/__stubs__/studio-runner.ts

@@ -1,104 +0,0 @@
-/**
- * Stub for @studio/runner used in tests when the package has not been built.
- * Reads from the actual runner template files so tool/integration tests work correctly.
- */
-import { readFile, readdir } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import yaml from 'js-yaml';
-
-const RUNNER_TEMPLATES = resolve(import.meta.dirname, '../../../runner/templates');
-const TOOL_TEMPLATES_DIR = resolve(RUNNER_TEMPLATES, 'tools');
-const INTEGRATION_TEMPLATES_DIR = resolve(RUNNER_TEMPLATES, 'integrations');
-
-// ── Tool functions ────────────────────────────────────────────────────────────
-
-export async function listAvailableToolTemplates(): Promise<{ name: string; description: string }[]> {
-  let files: string[];
-  try {
-    files = (await readdir(TOOL_TEMPLATES_DIR)).filter(f => f.endsWith('.tool.yaml')).sort();
-  } catch {
-    return [];
-  }
-  const result: { name: string; description: string }[] = [];
-  for (const file of files) {
-    const content = await readFile(resolve(TOOL_TEMPLATES_DIR, file), 'utf-8');
-    const def = yaml.load(content) as { description?: string };
-    result.push({ name: file.replace('.tool.yaml', ''), description: def.description ?? '' });
-  }
-  return result;
-}
-
-export async function getBundledToolTemplate(name: string): Promise<string | null> {
-  const filePath = resolve(TOOL_TEMPLATES_DIR, `${name}.tool.yaml`);
-  try {
-    return await readFile(filePath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
-export const BUILTIN_TOOL_NAMES = new Set(['repo-manager', 'shell', 'search', 'git']);
-
-// ── Integration functions ─────────────────────────────────────────────────────
-
-export async function getBundledIntegrationTemplate(name: string): Promise<string | null> {
-  const filePath = resolve(INTEGRATION_TEMPLATES_DIR, `${name}.integration.yaml`);
-  try {
-    return await readFile(filePath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
-export async function listAvailableIntegrationTemplates(): Promise<{ name: string; description: string }[]> {
-  let files: string[];
-  try {
-    files = (await readdir(INTEGRATION_TEMPLATES_DIR)).filter(f => f.endsWith('.integration.yaml')).sort();
-  } catch {
-    return [];
-  }
-  const result: { name: string; description: string }[] = [];
-  for (const file of files) {
-    const content = await readFile(resolve(INTEGRATION_TEMPLATES_DIR, file), 'utf-8');
-    const def = yaml.load(content) as { description?: string };
-    result.push({ name: file.replace('.integration.yaml', ''), description: def.description ?? '' });
-  }
-  return result;
-}
-
-export async function loadProjectIntegrations(): Promise<unknown[]> {
-  return [];
-}
-
-// ── Runtime stubs (used by run.ts — only needs to be importable) ──────────────
-
-export function createDefaultRegistry(..._args: unknown[]): unknown {
-  return {};
-}
-
-export class ToolRegistry {
-  addTool(..._args: unknown[]): void {}
-  getTools(): unknown[] { return []; }
-}
-
-export function createRepoManagerTools(..._args: unknown[]): unknown[] {
-  return [];
-}
-
-export async function loadProjectTools(..._args: unknown[]): Promise<unknown[]> {
-  return [];
-}
-
-export async function loadPlugins(..._args: unknown[]): Promise<unknown[]> {
-  return [];
-}
-
-export class MCPClient {
-  constructor(..._args: unknown[]) {}
-  async connect(): Promise<void> {}
-  async disconnect(): Promise<void> {}
-}
-
-export class StudioOAuthProvider {
-  constructor(..._args: unknown[]) {}
-}

package/tests/commands/api.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import { writeFile, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-// Use a unique fake home dir so tests don't collide with other test files using /tmp
-const FAKE_HOME = join(tmpdir(), `.studio-api-test-${process.pid}`);
-
-vi.mock('node:os', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('node:os')>();
-  return { ...actual, homedir: () => FAKE_HOME };
-});
-
-// Import after mocking
-const { apiStopCommand, apiStatusCommand, writePid, readPid, clearPid, isProcessAlive } = await import('../../src/commands/api.js');
-
-afterEach(async () => {
-  await clearPid();
-  // Remove the .studio dir created by writePid
-  await rm(join(FAKE_HOME, '.studio'), { recursive: true, force: true });
-});
-
-describe('writePid / readPid / clearPid', () => {
-  it('writes and reads PID with port', async () => {
-    await writePid(3700);
-    const entry = await readPid();
-    expect(entry).not.toBeNull();
-    expect(entry!.pid).toBe(process.pid);
-    expect(entry!.port).toBe(3700);
-  });
-
-  it('readPid returns null when no file exists', async () => {
-    const entry = await readPid();
-    expect(entry).toBeNull();
-  });
-
-  it('clearPid removes the file', async () => {
-    await writePid(3700);
-    await clearPid();
-    const entry = await readPid();
-    expect(entry).toBeNull();
-  });
-});
-
-describe('isProcessAlive', () => {
-  it('returns true for the current process', () => {
-    expect(isProcessAlive(process.pid)).toBe(true);
-  });
-
-  it('returns false for a non-existent PID', () => {
-    // PID 999999999 is very unlikely to exist
-    expect(isProcessAlive(999999999)).toBe(false);
-  });
-});
-
-describe('apiStopCommand', () => {
-  it('prints "not running" when no PID file', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await apiStopCommand();
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
-    consoleSpy.mockRestore();
-  });
-
-  it('prints "stale PID" and clears file when process is dead', async () => {
-    await writePid(3700);
-    // Overwrite with a dead PID
-    const pidFile = join(FAKE_HOME, '.studio', 'api.pid');
-    await writeFile(pidFile, '999999999:3700', 'utf-8');
-
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await apiStopCommand();
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('stale'));
-    expect(await readPid()).toBeNull();
-    consoleSpy.mockRestore();
-  });
-
-  it('sends SIGTERM and clears PID when process is the current process', async () => {
-    await writePid(3700);
-    const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true);
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    await apiStopCommand();
-
-    expect(killSpy).toHaveBeenCalledWith(process.pid, 'SIGTERM');
-    expect(await readPid()).toBeNull();
-    killSpy.mockRestore();
-    consoleSpy.mockRestore();
-  });
-});
-
-describe('apiStatusCommand', () => {
-  it('prints "not running" when no PID file', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    await apiStatusCommand({});
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
-    consoleSpy.mockRestore();
-  });
-
-  it('prints "running" when process is alive and health check succeeds', async () => {
-    await writePid(3700);
-    // Override with current PID (alive) and mock fetch
-    global.fetch = vi.fn().mockResolvedValue({ ok: true }) as unknown as typeof fetch;
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    await apiStatusCommand({});
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
-    consoleSpy.mockRestore();
-  });
-});