octo-dev 0.2.2

package/src/build/build-orchestrator.ts

@@ -0,0 +1,169 @@
+import os from 'node:os';
+import { logger } from '../shared/logger.js';
+import { onShutdown } from '../shared/shutdown.js';
+import { runHooks } from '../hooks/hook-runner.js';
+import type { HookContext } from '../hooks/hook-runner.js';
+import type { DependencyGraph } from '../graph/dependency-graph.js';
+import type { BuildEngine, BuildEngineRegistry, BuildTarget } from './ports/build-engine.port.js';
+import type { OctoManifest } from '../manifest/manifest-schema.js';
+import {
+  createBuildScheduler,
+  type BuildResult,
+  type BuildProgress,
+  type BuildStatus,
+} from './build-scheduler.js';
+
+export interface BuildOptions {
+  maxWorkers?: number;
+  workingDir: string;
+  manifest: OctoManifest;
+}
+
+export interface BuildOrchestrator {
+  buildAll(graph: DependencyGraph, registry: BuildEngineRegistry, options: BuildOptions): Promise<BuildResult>;
+  buildService(name: string, graph: DependencyGraph, registry: BuildEngineRegistry, options: BuildOptions): Promise<BuildResult>;
+  buildTargets(targets: string[], graph: DependencyGraph, registry: BuildEngineRegistry, options: BuildOptions): Promise<BuildResult>;
+}
+
+function formatDuration(seconds: number): string {
+  return seconds < 1 ? '<1s' : `${Math.round(seconds)}s`;
+}
+
+function renderProgressFn(progress: BuildProgress[]): void {
+  const lines = progress.map((p) => {
+    const icon = p.status === 'success' ? '✓' : p.status === 'failure' ? '✗' : p.status === 'building' ? '⟳' : p.status === 'cancelled' ? '⊘' : '○';
+    return `  ${icon} ${p.service} [${p.status}] ${formatDuration(p.durationSeconds)}`;
+  });
+  logger.info(`Build progress:\n${lines.join('\n')}`);
+}
+
+export function createBuildOrchestrator(): BuildOrchestrator {
+  const scheduler = createBuildScheduler();
+  let lastProgress: BuildProgress[] = [];
+
+  // Report partial state on shutdown
+  onShutdown(() => {
+    if (lastProgress.length > 0) {
+      const completed = lastProgress.filter((p) => p.status === 'success');
+      const inProgress = lastProgress.filter((p) => p.status === 'building');
+      const pending = lastProgress.filter((p) => p.status === 'pending');
+      logger.info(
+        `Estado parcial: ${completed.length} concluídos, ${inProgress.length} em andamento, ${pending.length} pendentes`,
+      );
+      if (completed.length > 0) {
+        logger.info(`  Concluídos: ${completed.map((p) => p.service).join(', ')}`);
+      }
+      if (inProgress.length > 0) {
+        logger.info(`  Em andamento: ${inProgress.map((p) => p.service).join(', ')}`);
+      }
+    }
+  });
+
+  function renderProgress(progress: BuildProgress[]): void {
+    lastProgress = progress;
+    renderProgressFn(progress);
+  }
+
+  async function runPreBuildHooks(options: BuildOptions): Promise<void> {
+    const hookContext: HookContext = {
+      target: 'all',
+      workingDir: options.workingDir,
+      manifest: options.manifest,
+    };
+    await runHooks('pre-build', hookContext);
+  }
+
+  function makeBuildFn(graph: DependencyGraph, registry: BuildEngineRegistry) {
+    return async (name: string) => {
+      const node = graph.getNode(name);
+      if (!node) {
+        return { success: false, output: `Node "${name}" not found in graph`, durationMs: 0 };
+      }
+
+      // Detect build file (Dockerfile by default for services)
+      const buildFile = 'Dockerfile';
+      const engine = registry.resolve(buildFile);
+
+      if (!engine) {
+        return { success: false, output: `No build engine found for "${buildFile}"`, durationMs: 0 };
+      }
+
+      const target: BuildTarget = {
+        name: node.name,
+        path: node.path,
+        buildFile,
+      };
+
+      return engine.build(target);
+    };
+  }
+
+  return {
+    async buildAll(graph, registry, options): Promise<BuildResult> {
+      await runPreBuildHooks(options);
+
+      const targets = graph.getNodeNames();
+      const plan = scheduler.schedule(graph, targets);
+      const maxWorkers = options.maxWorkers ?? os.cpus().length;
+
+      logger.info(`Building ${targets.length} targets (max ${maxWorkers} workers)...`);
+
+      const result = await scheduler.execute(
+        plan,
+        graph,
+        makeBuildFn(graph, registry),
+        renderProgress,
+        maxWorkers,
+      );
+
+      if (result.success) {
+        logger.info('All builds completed successfully.');
+      } else {
+        const failures = [...result.results.entries()]
+          .filter(([, r]) => r.status === 'failure')
+          .map(([name]) => name);
+        logger.error(`Build failed for: ${failures.join(', ')}`);
+      }
+
+      return result;
+    },
+
+    async buildService(name, graph, registry, options): Promise<BuildResult> {
+      await runPreBuildHooks(options);
+
+      const plan = scheduler.schedule(graph, [name]);
+      const maxWorkers = options.maxWorkers ?? os.cpus().length;
+
+      logger.info(`Building service "${name}"...`);
+
+      const result = await scheduler.execute(
+        plan,
+        graph,
+        makeBuildFn(graph, registry),
+        renderProgress,
+        maxWorkers,
+      );
+
+      return result;
+    },
+
+    async buildTargets(targets, graph, registry, options): Promise<BuildResult> {
+      await runPreBuildHooks(options);
+
+      const plan = scheduler.schedule(graph, targets);
+      const maxWorkers = options.maxWorkers ?? os.cpus().length;
+
+      logger.info(`Building ${targets.length} targets...`);
+
+      const result = await scheduler.execute(
+        plan,
+        graph,
+        makeBuildFn(graph, registry),
+        renderProgress,
+        maxWorkers,
+      );
+
+      return result;
+    },
+  };
+}

package/src/build/build-scheduler.ts

@@ -0,0 +1,174 @@
+import os from 'node:os';
+import type { DependencyGraph } from '../graph/dependency-graph.js';
+import type { BuildEngine, BuildTarget, BuildEngineResult } from './ports/build-engine.port.js';
+import { isShuttingDown } from '../shared/shutdown.js';
+
+export type BuildStatus = 'pending' | 'building' | 'success' | 'failure' | 'cancelled';
+
+export interface BuildPlan {
+  levels: string[][];
+}
+
+export interface BuildNodeResult {
+  status: BuildStatus;
+  duration: number;
+  error?: string;
+}
+
+export interface BuildResult {
+  success: boolean;
+  results: Map<string, BuildNodeResult>;
+}
+
+export type ProgressCallback = (progress: BuildProgress[]) => void;
+
+export interface BuildProgress {
+  service: string;
+  status: BuildStatus;
+  durationSeconds: number;
+}
+
+export interface BuildScheduler {
+  schedule(graph: DependencyGraph, targets: string[]): BuildPlan;
+  execute(
+    plan: BuildPlan,
+    graph: DependencyGraph,
+    buildFn: (name: string) => Promise<BuildEngineResult>,
+    onProgress: ProgressCallback,
+    maxWorkers?: number,
+  ): Promise<BuildResult>;
+}
+
+/** Collects all transitive dependents of a node in the graph */
+function getTransitiveDependents(graph: DependencyGraph, node: string): Set<string> {
+  const result = new Set<string>();
+  const queue = [node];
+  while (queue.length > 0) {
+    const current = queue.pop()!;
+    for (const dep of graph.getDependents(current)) {
+      if (!result.has(dep)) {
+        result.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return result;
+}
+
+export function createBuildScheduler(): BuildScheduler {
+  return {
+    schedule(graph: DependencyGraph, targets: string[]): BuildPlan {
+      const allLevels = graph.getIndependentGroups();
+      if (targets.length === 0) return { levels: allLevels };
+
+      // Filter levels to only include requested targets
+      const targetSet = new Set(targets);
+      const filtered = allLevels
+        .map((level) => level.filter((n) => targetSet.has(n)))
+        .filter((level) => level.length > 0);
+
+      return { levels: filtered };
+    },
+
+    async execute(
+      plan: BuildPlan,
+      graph: DependencyGraph,
+      buildFn: (name: string) => Promise<BuildEngineResult>,
+      onProgress: ProgressCallback,
+      maxWorkers?: number,
+    ): Promise<BuildResult> {
+      const concurrency = maxWorkers ?? os.cpus().length;
+      const results = new Map<string, BuildNodeResult>();
+      const cancelled = new Set<string>();
+      const startTimes = new Map<string, number>();
+
+      // Initialize all nodes as pending
+      for (const level of plan.levels) {
+        for (const node of level) {
+          results.set(node, { status: 'pending', duration: 0 });
+        }
+      }
+
+      // Progress reporting interval
+      const progressInterval = setInterval(() => {
+        const progress: BuildProgress[] = [];
+        for (const [name, result] of results) {
+          const start = startTimes.get(name);
+          const elapsed = start ? (Date.now() - start) / 1000 : 0;
+          progress.push({
+            service: name,
+            status: result.status,
+            durationSeconds: result.status === 'building' ? elapsed : result.duration / 1000,
+          });
+        }
+        onProgress(progress);
+      }, 1000);
+
+      try {
+        for (const level of plan.levels) {
+          if (isShuttingDown()) break;
+
+          const activeNodes = level.filter((n) => !cancelled.has(n));
+
+          // Execute level in parallel, limited by concurrency
+          const chunks: string[][] = [];
+          for (let i = 0; i < activeNodes.length; i += concurrency) {
+            chunks.push(activeNodes.slice(i, i + concurrency));
+          }
+
+          for (const chunk of chunks) {
+            const promises = chunk.map(async (node) => {
+              if (cancelled.has(node) || isShuttingDown()) {
+                results.set(node, { status: 'cancelled', duration: 0 });
+                return;
+              }
+
+              startTimes.set(node, Date.now());
+              results.set(node, { status: 'building', duration: 0 });
+
+              try {
+                const engineResult = await buildFn(node);
+                const duration = Date.now() - startTimes.get(node)!;
+
+                if (engineResult.success) {
+                  results.set(node, { status: 'success', duration });
+                } else {
+                  results.set(node, { status: 'failure', duration, error: engineResult.output });
+                  // Cancel all transitive dependents
+                  const dependents = getTransitiveDependents(graph, node);
+                  for (const dep of dependents) {
+                    cancelled.add(dep);
+                    results.set(dep, { status: 'cancelled', duration: 0 });
+                  }
+                }
+              } catch (err) {
+                const duration = Date.now() - startTimes.get(node)!;
+                const error = err instanceof Error ? err.message : String(err);
+                results.set(node, { status: 'failure', duration, error });
+                // Cancel all transitive dependents
+                const dependents = getTransitiveDependents(graph, node);
+                for (const dep of dependents) {
+                  cancelled.add(dep);
+                  results.set(dep, { status: 'cancelled', duration: 0 });
+                }
+              }
+            });
+
+            await Promise.all(promises);
+          }
+        }
+      } finally {
+        clearInterval(progressInterval);
+      }
+
+      const success = [...results.values()].every(
+        (r) => r.status === 'success' || r.status === 'cancelled',
+      ) && [...results.values()].some((r) => r.status === 'success');
+
+      // Overall success: no failures
+      const hasFailure = [...results.values()].some((r) => r.status === 'failure');
+
+      return { success: !hasFailure, results };
+    },
+  };
+}

package/src/build/ports/build-engine.port.ts

@@ -0,0 +1,38 @@
+/** Port — interface that the build orchestrator consumes */
+export interface BuildTarget {
+  name: string;
+  path: string;
+  buildFile: string;
+  context?: string;
+}
+
+export interface BuildEngineResult {
+  success: boolean;
+  output: string;
+  durationMs: number;
+}
+
+export interface BuildEngine {
+  name: string;
+  build(target: BuildTarget): Promise<BuildEngineResult>;
+  isAvailable(): Promise<boolean>;
+  detect(buildFile: string): boolean;
+}
+
+/** Registry — resolves the correct adapter by build_file */
+export interface BuildEngineRegistry {
+  register(engine: BuildEngine): void;
+  resolve(buildFile: string): BuildEngine | undefined;
+}
+
+export class DefaultBuildEngineRegistry implements BuildEngineRegistry {
+  private engines: BuildEngine[] = [];
+
+  register(engine: BuildEngine): void {
+    this.engines.push(engine);
+  }
+
+  resolve(buildFile: string): BuildEngine | undefined {
+    return this.engines.find((e) => e.detect(buildFile));
+  }
+}

package/src/cli/build.command.ts

@@ -0,0 +1,101 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseManifest } from '../manifest/manifest-parser.js';
+import { buildGraphFromManifest } from '../graph/build-graph.js';
+import { createBuildOrchestrator } from '../build/build-orchestrator.js';
+import { createAffectedDetector } from '../build/affected-detector.js';
+import { DefaultBuildEngineRegistry } from '../build/ports/build-engine.port.js';
+import { DockerBuildEngine } from '../build/adapters/docker-build-engine.adapter.js';
+import { OctoError } from '../shared/errors.js';
+import { logger } from '../shared/logger.js';
+import type { BuildResult } from '../build/build-scheduler.js';
+
+/** Resolve entry name from a ServiceEntry or PackageEntry */
+function entryName(entry: string | Record<string, unknown>): string {
+  if (typeof entry === 'string') return entry;
+  return Object.keys(entry)[0];
+}
+
+export async function buildCommand(service?: string, opts?: { affected?: boolean }): Promise<void> {
+  const rootDir = process.cwd();
+  const manifestPath = resolve(rootDir, 'octo.yaml');
+
+  let content: string;
+  try {
+    content = readFileSync(manifestPath, 'utf-8');
+  } catch {
+    throw new OctoError('octo.yaml não encontrado. Execute `octo init` primeiro.');
+  }
+
+  const parsed = parseManifest(content, manifestPath);
+  if (!parsed.ok) throw parsed.error;
+
+  const manifest = parsed.value;
+  const graph = buildGraphFromManifest(manifest, rootDir);
+
+  // Set up build engine registry
+  const registry = new DefaultBuildEngineRegistry();
+  registry.register(new DockerBuildEngine());
+
+  const orchestrator = createBuildOrchestrator();
+  const buildOptions = { workingDir: rootDir, manifest };
+
+  let result: BuildResult | undefined;
+
+  if (opts?.affected) {
+    // --affected: build only modified services
+    const detector = createAffectedDetector();
+    const affected = await detector.detect(graph, rootDir);
+
+    if (affected.length === 0) {
+      logger.info('Nenhum serviço afetado detectado.');
+      return;
+    }
+
+    logger.info(`Serviços afetados: ${affected.join(', ')}`);
+    result = await orchestrator.buildTargets(affected, graph, registry, buildOptions);
+
+    if (result.success) {
+      await detector.recordBuild(affected, rootDir);
+    }
+  } else if (service) {
+    // Validate service name against manifest
+    const allNames = [
+      ...manifest.services.map(entryName),
+      ...manifest.packages.map(entryName),
+    ];
+
+    if (!allNames.includes(service)) {
+      throw new OctoError(
+        `Serviço "${service}" não encontrado no manifesto.\nDisponíveis: ${allNames.join(', ')}`,
+      );
+    }
+
+    result = await orchestrator.buildService(service, graph, registry, buildOptions);
+
+    if (result.success) {
+      const detector = createAffectedDetector();
+      const r = result;
+      const builtNames = [...r.results.keys()].filter(
+        (n) => r.results.get(n)?.status === 'success',
+      );
+      await detector.recordBuild(builtNames, rootDir);
+    }
+  } else {
+    // No args: build all
+    result = await orchestrator.buildAll(graph, registry, buildOptions);
+
+    if (result.success) {
+      const detector = createAffectedDetector();
+      const r = result;
+      const builtNames = [...r.results.keys()].filter(
+        (n) => r.results.get(n)?.status === 'success',
+      );
+      await detector.recordBuild(builtNames, rootDir);
+    }
+  }
+
+  if (result && !result.success) {
+    process.exitCode = 1;
+  }
+}

package/src/cli/bump.command.ts

@@ -0,0 +1,98 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseManifest } from '../manifest/manifest-parser.js';
+import { buildGraphFromManifest } from '../graph/build-graph.js';
+import { runHooks } from '../hooks/hook-runner.js';
+import { VersionBumper, type BumpType } from '../version/version-bumper.js';
+import { VersionPropagator } from '../version/version-propagator.js';
+import { ChangelogGenerator } from '../version/changelog-generator.js';
+import { run } from '../shared/process-runner.js';
+import { OctoError } from '../shared/errors.js';
+import { logger } from '../shared/logger.js';
+
+function entryName(entry: string | Record<string, unknown>): string {
+  if (typeof entry === 'string') return entry;
+  return Object.keys(entry)[0];
+}
+
+export interface BumpCommandOpts {
+  install?: boolean;
+  push?: boolean;
+  tag?: boolean;
+  auto?: boolean;
+}
+
+export async function bumpCommand(pkg: string, type: string, opts: BumpCommandOpts): Promise<void> {
+  const rootDir = process.cwd();
+  const manifestPath = resolve(rootDir, 'octo.yaml');
+
+  let content: string;
+  try {
+    content = readFileSync(manifestPath, 'utf-8');
+  } catch {
+    throw new OctoError('octo.yaml not found. Run `octo init` first.');
+  }
+
+  const parsed = parseManifest(content, manifestPath);
+  if (!parsed.ok) throw parsed.error;
+
+  const manifest = parsed.value;
+
+  const allNames = [
+    ...manifest.services.map(entryName),
+    ...manifest.packages.map(entryName),
+  ];
+
+  if (!allNames.includes(pkg)) {
+    throw new OctoError(
+      `Package "${pkg}" not found in manifest.\nAvailable: ${allNames.join(', ')}`,
+    );
+  }
+
+  const graph = buildGraphFromManifest(manifest, rootDir);
+  const node = graph.getNode(pkg);
+
+  if (!node) {
+    throw new OctoError(`Could not resolve directory for package "${pkg}".`);
+  }
+
+  // Pre-bump hooks
+  await runHooks('pre-bump', { target: pkg, workingDir: node.path, manifest });
+
+  const bumpType = (type || 'patch') as BumpType;
+  const bumper = new VersionBumper();
+  const bumpResult = await bumper.bump(node.path, pkg, bumpType, {
+    push: opts.push,
+    tag: opts.tag,
+    auto: opts.auto,
+  });
+
+  // Generate changelog (uses LLM when available)
+  const changelog = new ChangelogGenerator();
+  await changelog.generate(node.path, bumpResult.newVersion);
+
+  // Propagate version to dependents
+  const propagator = new VersionPropagator(graph);
+  const propagation = await propagator.propagate(pkg, bumpResult.newVersion);
+
+  // --install: run pnpm install in updated projects
+  if (opts.install) {
+    const updatedProjects = propagation.entries
+      .filter((e) => !e.skipped)
+      .map((e) => e.project);
+
+    for (const project of updatedProjects) {
+      const projectNode = graph.getNode(project);
+      if (!projectNode) continue;
+
+      logger.info(`Running pnpm install in ${project}...`);
+      const result = await run('pnpm', ['install'], { cwd: projectNode.path });
+
+      if (result.exitCode !== 0) {
+        logger.error(`pnpm install failed in ${project}: ${(result.stderr || result.stdout).trim()}`);
+      }
+    }
+  }
+
+  logger.info(`Done: ${pkg} ${bumpResult.previousVersion} → ${bumpResult.newVersion}`);
+}

package/src/cli/down.command.ts

@@ -0,0 +1,36 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseManifest } from '../manifest/manifest-parser.js';
+import { buildGraphFromManifest } from '../graph/build-graph.js';
+import { createInfraManager } from '../infra/infra-manager.js';
+import { logger } from '../shared/logger.js';
+import { OctoError } from '../shared/errors.js';
+
+export async function downCommand(opts: { volumes?: boolean }): Promise<void> {
+  const rootDir = process.cwd();
+  const manifestPath = resolve(rootDir, 'octo.yaml');
+
+  let content: string;
+  try {
+    content = readFileSync(manifestPath, 'utf-8');
+  } catch {
+    throw new OctoError('octo.yaml não encontrado. Execute `octo init` primeiro.');
+  }
+
+  const parsed = parseManifest(content, manifestPath);
+  if (!parsed.ok) throw parsed.error;
+
+  const graph = buildGraphFromManifest(parsed.value, rootDir);
+  const servicePaths = graph.getNodeNames()
+    .map((name) => graph.getNode(name)?.path)
+    .filter((p): p is string => !!p);
+
+  const manager = createInfraManager(servicePaths);
+  const result = await manager.down({ volumes: opts.volumes });
+
+  if (!result.success) {
+    throw new OctoError(result.message);
+  }
+
+  logger.info(result.message);
+}

package/src/cli/graph.command.ts

@@ -0,0 +1,40 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseManifest } from '../manifest/manifest-parser.js';
+import { buildGraphFromManifest } from '../graph/build-graph.js';
+import { OctoError } from '../shared/errors.js';
+
+/**
+ * `octo graph` — exibe grafo de dependências no stdout em formato de lista de adjacência indentada.
+ */
+export async function graphCommand(): Promise<void> {
+  const cwd = process.cwd();
+  const manifestPath = join(cwd, 'octo.yaml');
+
+  let content: string;
+  try {
+    content = readFileSync(manifestPath, 'utf-8');
+  } catch {
+    throw new OctoError(`Não foi possível ler ${manifestPath}. Execute "octo init" primeiro.`);
+  }
+
+  const result = parseManifest(content, manifestPath);
+  if (!result.ok) {
+    throw result.error;
+  }
+
+  const graph = buildGraphFromManifest(result.value, cwd);
+  const sortResult = graph.topologicalSort();
+
+  if (!sortResult.ok) {
+    throw sortResult.error;
+  }
+
+  // Print each node followed by its dependencies indented with 2 spaces
+  for (const name of sortResult.value) {
+    process.stdout.write(`${name}\n`);
+    for (const dep of graph.getDependencies(name)) {
+      process.stdout.write(`  ${dep}\n`);
+    }
+  }
+}