octo-dev 0.2.2

package/src/cli/index.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { triggerShutdown } from '../shared/shutdown.js';
+
+// Graceful shutdown on SIGINT (Ctrl+C) and SIGTERM
+process.on('SIGINT', () => triggerShutdown('SIGINT'));
+process.on('SIGTERM', () => triggerShutdown('SIGTERM'));
+
+const program = new Command();
+
+program
+  .name('octo')
+  .description('Monorepo build orchestration, versioning, and infrastructure CLI')
+  .version('0.1.0');
+
+program
+  .command('init')
+  .description('Escaneia o monorepo e gera octo.yaml')
+  .option('--standalone', 'Gera manifesto apenas para o projeto corrente')
+  .action(async (opts) => {
+    const { initCommand } = await import('./init.command.js');
+    await initCommand(opts);
+  });
+
+program
+  .command('graph')
+  .description('Exibe o grafo de dependências')
+  .action(async () => {
+    const { graphCommand } = await import('./graph.command.js');
+    await graphCommand();
+  });
+
+program
+  .command('build [service]')
+  .description('Builda serviços do monorepo')
+  .option('--affected', 'Builda apenas serviços afetados')
+  .action(async (service, opts) => {
+    const { buildCommand } = await import('./build.command.js');
+    await buildCommand(service, opts);
+  });
+
+program
+  .command('bump <package>')
+  .description('Bump package version with semver')
+  .argument('[type]', 'Bump type: patch | minor | major', 'patch')
+  .option('--install', 'Run pnpm install in updated dependents')
+  .option('--push', 'Push commit and tags to remote after bump')
+  .option('--tag', 'Create a git tag for the new version')
+  .option('--auto', 'Non-interactive mode: skip confirmations, tag and push automatically')
+  .action(async (pkg, type, opts) => {
+    const { bumpCommand } = await import('./bump.command.js');
+    await bumpCommand(pkg, type, opts);
+  });
+
+program
+  .command('up [service]')
+  .description('Sobe infraestrutura local')
+  .action(async (service) => {
+    const { upCommand } = await import('./up.command.js');
+    await upCommand(service);
+  });
+
+program
+  .command('down')
+  .description('Para infraestrutura local')
+  .option('--volumes', 'Remove volumes também')
+  .action(async (opts) => {
+    const { downCommand } = await import('./down.command.js');
+    await downCommand(opts);
+  });
+
+program
+  .command('status')
+  .description('Exibe status dos containers')
+  .action(async () => {
+    const { statusCommand } = await import('./status.command.js');
+    await statusCommand();
+  });
+
+program.parse();

package/src/cli/init.command.ts

@@ -0,0 +1,106 @@
+import { readdir, readFile, access, writeFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { logger } from '../shared/logger.js';
+import { OctoError } from '../shared/errors.js';
+import { printManifest } from '../manifest/manifest-printer.js';
+import type { OctoManifest } from '../manifest/manifest-schema.js';
+
+const EXCLUDED_DIRS = new Set(['node_modules', 'dist']);
+const MAX_DEPTH = 5;
+
+interface DiscoveredProject {
+  name: string;
+  relativePath: string;
+  hasDockerfile: boolean;
+}
+
+function isExcluded(name: string): boolean {
+  return EXCLUDED_DIRS.has(name) || name.startsWith('.');
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function scanDirectory(
+  dir: string,
+  rootDir: string,
+  depth: number,
+  results: DiscoveredProject[],
+): Promise<void> {
+  if (depth > MAX_DEPTH) return;
+
+  const pkgPath = join(dir, 'package.json');
+  if (await exists(pkgPath)) {
+    try {
+      const content = await readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content);
+      if (pkg.name) {
+        const hasDockerfile = await exists(join(dir, 'Dockerfile'));
+        results.push({
+          name: pkg.name,
+          relativePath: './' + relative(rootDir, dir),
+          hasDockerfile,
+        });
+      }
+    } catch {
+      // Invalid JSON — skip
+    }
+  }
+
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || isExcluded(entry.name)) continue;
+    await scanDirectory(join(dir, entry.name), rootDir, depth + 1, results);
+  }
+}
+
+export async function initCommand(opts: { standalone?: boolean }): Promise<void> {
+  const rootDir = process.cwd();
+  const results: DiscoveredProject[] = [];
+
+  if (opts.standalone) {
+    // Only scan current directory, no recursion into subdirectories
+    const pkgPath = join(rootDir, 'package.json');
+    if (await exists(pkgPath)) {
+      try {
+        const content = await readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        if (pkg.name) {
+          const hasDockerfile = await exists(join(rootDir, 'Dockerfile'));
+          results.push({ name: pkg.name, relativePath: '.', hasDockerfile });
+        }
+      } catch {
+        // Invalid JSON
+      }
+    }
+  } else {
+    await scanDirectory(rootDir, rootDir, 0, results);
+  }
+
+  if (results.length === 0) {
+    throw new OctoError('Nenhum pacote com package.json válido encontrado.', 1);
+  }
+
+  const services = results.filter((p) => p.hasDockerfile).map((p) => p.name);
+  const packages = results.filter((p) => !p.hasDockerfile).map((p) => p.name);
+
+  const manifest: OctoManifest = { services, packages };
+  const yaml = printManifest(manifest);
+
+  const outputPath = join(rootDir, 'octo.yaml');
+  await writeFile(outputPath, yaml, 'utf-8');
+
+  logger.info(`octo.yaml gerado com ${services.length} serviço(s) e ${packages.length} pacote(s).`);
+}

package/src/cli/status.command.ts

@@ -0,0 +1,46 @@
+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 statusCommand(): 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 containers = await manager.status();
+
+  if (containers.length === 0) {
+    logger.info('Nenhum container em execução.');
+    return;
+  }
+
+  // Print table header
+  const header = `${'NOME'.padEnd(30)} ${'IMAGEM'.padEnd(35)} ${'ESTADO'.padEnd(12)} PORTA`;
+  console.log(header);
+  console.log('-'.repeat(header.length));
+
+  for (const c of containers) {
+    console.log(
+      `${c.name.padEnd(30)} ${c.image.padEnd(35)} ${c.state.padEnd(12)} ${c.port}`,
+    );
+  }
+}

package/src/cli/up.command.ts

@@ -0,0 +1,52 @@
+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 upCommand(service?: string): 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);
+
+  // Resolve service paths from graph
+  let targetServices: string[] | undefined;
+  if (service) {
+    const node = graph.getNode(service);
+    if (!node) {
+      const available = graph.getNodeNames().join(', ');
+      throw new OctoError(`Serviço "${service}" não encontrado. Disponíveis: ${available}`);
+    }
+    // Include service + its dependencies
+    const deps = graph.getDependencies(service);
+    targetServices = [service, ...deps];
+  }
+
+  // Collect all service paths from graph nodes
+  const allNames = targetServices ?? graph.getNodeNames();
+  const servicePaths = allNames
+    .map((name) => graph.getNode(name)?.path)
+    .filter((p): p is string => !!p);
+
+  const manager = createInfraManager(servicePaths);
+  const result = await manager.up(targetServices);
+
+  if (!result.success) {
+    throw new OctoError(result.message);
+  }
+
+  logger.info(result.message);
+}

package/src/graph/aggregated-graph.ts

@@ -0,0 +1,77 @@
+import { readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { DependencyGraph } from './dependency-graph.js';
+import { buildGraphFromManifest } from './build-graph.js';
+import { parseManifest } from '../manifest/manifest-parser.js';
+import type { DiscoveredManifest } from '../manifest/manifest-discovery.js';
+import { logger } from '../shared/logger.js';
+
+/**
+ * Builds a unified DependencyGraph from multiple discovered manifests (aggregated mode).
+ * Resolves cross-project dependencies: if service S in manifest B depends on package P
+ * declared in manifest A, adds an edge from S to P in the unified graph.
+ */
+export function buildAggregatedGraph(manifests: DiscoveredManifest[]): DependencyGraph {
+  const unified = new DependencyGraph();
+  const localGraphs: DependencyGraph[] = [];
+
+  for (const manifest of manifests) {
+    let content: string;
+    try {
+      content = readFileSync(manifest.path, 'utf-8');
+    } catch {
+      logger.warn(`Could not read manifest: ${manifest.path}`);
+      continue;
+    }
+
+    const result = parseManifest(content, manifest.path);
+    if (!result.ok) {
+      logger.warn(`Failed to parse manifest ${manifest.path}: ${result.error.message}`);
+      continue;
+    }
+
+    const rootDir = dirname(manifest.path);
+    const graph = buildGraphFromManifest(result.value, rootDir);
+    localGraphs.push(graph);
+
+    // Merge nodes into unified graph
+    for (const name of graph.getNodeNames()) {
+      const node = graph.getNode(name)!;
+      unified.addNode(node);
+    }
+
+    // Merge local edges
+    for (const name of graph.getNodeNames()) {
+      for (const dep of graph.getDependencies(name)) {
+        unified.addEdge(name, dep);
+      }
+    }
+  }
+
+  // Resolve cross-project edges: for each node, check if its package.json
+  // dependencies reference a node from another manifest's graph
+  const allNodeNames = new Set(unified.getNodeNames());
+
+  for (const name of unified.getNodeNames()) {
+    const node = unified.getNode(name)!;
+    // Read package.json to find all dependencies
+    const pkgPath = `${node.path}/package.json`;
+    let pkg: { dependencies?: Record<string, string>; devDependencies?: Record<string, string> };
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    } catch {
+      continue;
+    }
+
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const depName of Object.keys(allDeps)) {
+      // Only add edge if the dependency is an internal node and not already connected
+      if (allNodeNames.has(depName) && !unified.getDependencies(name).includes(depName)) {
+        unified.addEdge(name, depName);
+        logger.info(`Cross-project edge: ${name} → ${depName}`);
+      }
+    }
+  }
+
+  return unified;
+}

package/src/graph/build-graph.ts

@@ -0,0 +1,125 @@
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { DependencyGraph, type GraphNode } from './dependency-graph.js';
+import type { OctoManifest, ServiceEntry, PackageEntry } from '../manifest/manifest-schema.js';
+
+interface PackageJson {
+  name?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+/** Extract the name and optional path override from a manifest entry */
+function resolveEntry(entry: ServiceEntry | PackageEntry): { name: string; path?: string } {
+  if (typeof entry === 'string') return { name: entry };
+  // Object format: { "auth": { path?: "./custom" } }
+  const key = Object.keys(entry)[0];
+  const config = (entry as Record<string, { path?: string }>)[key];
+  return { name: key, path: config?.path };
+}
+
+/**
+ * Recursively search for a directory containing a package.json whose `name` matches `targetName`.
+ * Searches up to depth 3 from rootDir.
+ */
+function findPackageDir(rootDir: string, targetName: string, maxDepth = 3): string | undefined {
+  function search(dir: string, depth: number): string | undefined {
+    if (depth > maxDepth) return undefined;
+
+    const pkgPath = join(dir, 'package.json');
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as PackageJson;
+        if (pkg.name === targetName) return dir;
+      } catch { /* skip invalid json */ }
+    }
+
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return undefined;
+    }
+
+    for (const entry of entries) {
+      if (entry === 'node_modules' || entry === 'dist' || entry.startsWith('.')) continue;
+      const full = join(dir, entry);
+      try {
+        if (statSync(full).isDirectory()) {
+          const found = search(full, depth + 1);
+          if (found) return found;
+        }
+      } catch { /* skip inaccessible */ }
+    }
+    return undefined;
+  }
+
+  return search(rootDir, 0);
+}
+
+/** Read a package.json from a directory, returning undefined if not found */
+function readPackageJson(dir: string): PackageJson | undefined {
+  const pkgPath = join(dir, 'package.json');
+  if (!existsSync(pkgPath)) return undefined;
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf-8')) as PackageJson;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Build a DependencyGraph from an OctoManifest.
+ * Reads each service/package's package.json and adds edges only for internal dependencies.
+ */
+export function buildGraphFromManifest(manifest: OctoManifest, rootDir: string): DependencyGraph {
+  const graph = new DependencyGraph();
+  const resolvedPaths = new Map<string, string>();
+
+  // Collect all declared names (services + packages)
+  const allEntries: Array<{ name: string; path?: string; type: 'service' | 'package' }> = [];
+
+  for (const entry of manifest.services) {
+    const resolved = resolveEntry(entry);
+    allEntries.push({ ...resolved, type: 'service' });
+  }
+  for (const entry of manifest.packages) {
+    const resolved = resolveEntry(entry);
+    allEntries.push({ ...resolved, type: 'package' });
+  }
+
+  // Resolve paths and add nodes
+  for (const entry of allEntries) {
+    let dir: string | undefined;
+
+    if (entry.path) {
+      dir = resolve(rootDir, entry.path);
+    } else {
+      dir = findPackageDir(rootDir, entry.name);
+    }
+
+    if (!dir) continue;
+
+    resolvedPaths.set(entry.name, dir);
+    const node: GraphNode = { name: entry.name, type: entry.type, path: dir };
+    graph.addNode(node);
+  }
+
+  // Set of all internal package names for quick lookup
+  const internalNames = new Set(resolvedPaths.keys());
+
+  // Add edges based on package.json dependencies
+  for (const [name, dir] of resolvedPaths) {
+    const pkg = readPackageJson(dir);
+    if (!pkg) continue;
+
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const depName of Object.keys(allDeps)) {
+      if (internalNames.has(depName)) {
+        graph.addEdge(name, depName);
+      }
+    }
+  }
+
+  return graph;
+}

package/src/graph/dependency-graph.ts

@@ -0,0 +1,82 @@
+import { CycleError } from '../shared/errors.js';
+import { topologicalSort } from './topological-sort.js';
+
+export interface GraphNode {
+  name: string;
+  type: 'service' | 'package';
+  path: string;
+}
+
+export type SortResult =
+  | { ok: true; value: string[] }
+  | { ok: false; error: CycleError };
+
+export class DependencyGraph {
+  /** node name → GraphNode metadata */
+  private nodes = new Map<string, GraphNode>();
+  /** node name → set of dependency names (edges: from depends on to) */
+  private edges = new Map<string, Set<string>>();
+  /** reverse edges: node name → set of dependents */
+  private reverseEdges = new Map<string, Set<string>>();
+
+  addNode(node: GraphNode): void {
+    this.nodes.set(node.name, node);
+    if (!this.edges.has(node.name)) this.edges.set(node.name, new Set());
+    if (!this.reverseEdges.has(node.name)) this.reverseEdges.set(node.name, new Set());
+  }
+
+  addEdge(from: string, to: string): void {
+    // from depends on to
+    if (!this.edges.has(from)) this.edges.set(from, new Set());
+    if (!this.reverseEdges.has(to)) this.reverseEdges.set(to, new Set());
+    this.edges.get(from)!.add(to);
+    this.reverseEdges.get(to)!.add(from);
+  }
+
+  /** Get packages that `packageName` depends on */
+  getDependencies(packageName: string): string[] {
+    return [...(this.edges.get(packageName) ?? [])];
+  }
+
+  /** Get packages that depend on `packageName` */
+  getDependents(packageName: string): string[] {
+    return [...(this.reverseEdges.get(packageName) ?? [])];
+  }
+
+  /** Group nodes into independent parallel levels (BFS layers) */
+  getIndependentGroups(): string[][] {
+    const sortResult = this.topologicalSort();
+    if (!sortResult.ok) return [];
+
+    const sorted = sortResult.value;
+    const levels: string[][] = [];
+    const assigned = new Set<string>();
+
+    while (assigned.size < sorted.length) {
+      const level = sorted.filter(
+        (n) => !assigned.has(n) && this.getDependencies(n).every((d) => assigned.has(d)),
+      );
+      if (level.length === 0) break;
+      levels.push(level);
+      level.forEach((n) => assigned.add(n));
+    }
+
+    return levels;
+  }
+
+  topologicalSort(): SortResult {
+    return topologicalSort(this.edges);
+  }
+
+  getNode(name: string): GraphNode | undefined {
+    return this.nodes.get(name);
+  }
+
+  getNodeNames(): string[] {
+    return [...this.nodes.keys()];
+  }
+
+  get size(): number {
+    return this.nodes.size;
+  }
+}

package/src/graph/index.ts

@@ -0,0 +1,4 @@
+export { DependencyGraph, type GraphNode, type SortResult } from './dependency-graph.js';
+export { topologicalSort } from './topological-sort.js';
+export { buildGraphFromManifest } from './build-graph.js';
+export { buildAggregatedGraph } from './aggregated-graph.js';

package/src/graph/topological-sort.ts

@@ -0,0 +1,104 @@
+import { CycleError } from '../shared/errors.js';
+
+export type SortResult =
+  | { ok: true; value: string[] }
+  | { ok: false; error: CycleError };
+
+/**
+ * Kahn's Algorithm — topological sort with cycle detection.
+ * `edges` maps each node to the set of nodes it depends on (outgoing edges point to dependencies).
+ */
+export function topologicalSort(edges: Map<string, Set<string>>): SortResult {
+  // In-degree: how many nodes depend on this node? No — in-degree = how many dependencies point INTO this node.
+  // Actually for Kahn's: in-degree of a node = number of prerequisites it has.
+  // We want to produce an order where dependencies come first.
+  // edges: from → {deps it depends on}. So "from depends on to" means to must come before from.
+  // In-degree of `from` = edges.get(from).size (number of things it depends on).
+
+  const inDegree = new Map<string, number>();
+  // Initialize all nodes
+  for (const [node] of edges) {
+    if (!inDegree.has(node)) inDegree.set(node, 0);
+  }
+  // Calculate in-degree: for each node, its in-degree is the count of its dependencies
+  for (const [node, deps] of edges) {
+    inDegree.set(node, deps.size);
+    // Ensure all dependency targets are in the map
+    for (const dep of deps) {
+      if (!inDegree.has(dep)) inDegree.set(dep, 0);
+    }
+  }
+
+  // Enqueue nodes with in-degree 0 (no dependencies)
+  const queue: string[] = [];
+  for (const [node, degree] of inDegree) {
+    if (degree === 0) queue.push(node);
+  }
+
+  const result: string[] = [];
+
+  while (queue.length > 0) {
+    const node = queue.shift()!;
+    result.push(node);
+
+    // For each other node that depends on `node`, decrement its in-degree
+    for (const [candidate, deps] of edges) {
+      if (deps.has(node)) {
+        const newDegree = inDegree.get(candidate)! - 1;
+        inDegree.set(candidate, newDegree);
+        if (newDegree === 0) queue.push(candidate);
+      }
+    }
+  }
+
+  if (result.length !== inDegree.size) {
+    // Cycle detected — trace it
+    const cycleNodes = [...inDegree.entries()]
+      .filter(([, d]) => d > 0)
+      .map(([n]) => n);
+    const cycle = traceCycle(edges, cycleNodes);
+    return {
+      ok: false,
+      error: new CycleError(
+        `Dependency cycle detected: ${cycle.join(' -> ')}`,
+        cycle,
+      ),
+    };
+  }
+
+  return { ok: true, value: result };
+}
+
+/** Trace a cycle path from the remaining nodes with in-degree > 0 */
+function traceCycle(edges: Map<string, Set<string>>, cycleNodes: string[]): string[] {
+  const inCycle = new Set(cycleNodes);
+  if (cycleNodes.length === 0) return [];
+
+  const start = cycleNodes[0];
+  const path: string[] = [start];
+  const visited = new Set<string>([start]);
+  let current = start;
+
+  while (true) {
+    const deps = edges.get(current);
+    if (!deps) break;
+    const next = [...deps].find((d) => inCycle.has(d) && !visited.has(d));
+    if (!next) {
+      // Close the cycle back to start
+      const closing = [...deps].find((d) => d === start);
+      if (closing) path.push(closing);
+      else {
+        // Find any node already in path to close
+        const back = [...deps].find((d) => path.includes(d));
+        if (back) path.push(back);
+        else path.push(start);
+      }
+      break;
+    }
+    path.push(next);
+    visited.add(next);
+    current = next;
+  }
+
+  return path;
+}