octo-dev 0.2.2

package/src/hooks/hook-runner.ts

@@ -0,0 +1,57 @@
+import { run } from '../shared/process-runner.js';
+import { logger } from '../shared/logger.js';
+import type { OctoManifest, HookDefinition } from '../manifest/manifest-schema.js';
+
+export type HookTrigger = 'pre-build' | 'pre-bump';
+
+export interface HookContext {
+  target: string;
+  workingDir: string;
+  manifest: OctoManifest;
+}
+
+export interface HookResult {
+  success: boolean;
+  hook: string;
+  output?: string;
+  durationMs: number;
+}
+
+/** Executes hooks sequentially in declaration order. Aborts on first failure. */
+export async function runHooks(trigger: HookTrigger, context: HookContext): Promise<HookResult[]> {
+  const hooks: HookDefinition[] = context.manifest.hooks?.[trigger] ?? [];
+
+  if (hooks.length === 0) return [];
+
+  const results: HookResult[] = [];
+
+  for (const hook of hooks) {
+    logger.info(`Running hook "${hook.name}" (${trigger})...`);
+    const start = Date.now();
+
+    const result = await run(hook.command, [], { cwd: context.workingDir });
+    const durationMs = Date.now() - start;
+    const output = (result.stdout + result.stderr).trim() || undefined;
+
+    if (result.exitCode !== 0) {
+      logger.error(`Hook "${hook.name}" failed (exit ${result.exitCode})`);
+      results.push({ success: false, hook: hook.name, output, durationMs });
+      throw new HookError(hook.name, trigger, output);
+    }
+
+    results.push({ success: true, hook: hook.name, output, durationMs });
+  }
+
+  return results;
+}
+
+export class HookError extends Error {
+  constructor(
+    public readonly hook: string,
+    public readonly trigger: HookTrigger,
+    public readonly output?: string,
+  ) {
+    super(`Hook "${hook}" failed during ${trigger}${output ? `: ${output}` : ''}`);
+    this.name = 'HookError';
+  }
+}

package/src/infra/compose-aggregator.ts

@@ -0,0 +1,152 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+
+/** A discovered docker-compose.yml from a service directory */
+export interface DiscoveredCompose {
+  serviceName: string;
+  path: string;
+  content: DockerComposeDocument;
+}
+
+/** Parsed docker-compose document structure */
+export interface DockerComposeDocument {
+  services?: Record<string, any>;
+  networks?: Record<string, any>;
+  volumes?: Record<string, any>;
+  [key: string]: any;
+}
+
+/** Merged compose output */
+export interface MergedCompose {
+  services: Record<string, any>;
+  networks: Record<string, any>;
+  volumes: Record<string, any>;
+}
+
+/** Conflict detected during merge */
+export interface ComposeConflict {
+  type: 'port' | 'volume_name' | 'service_name';
+  sources: string[];
+  description: string;
+}
+
+/** Result of a merge operation */
+export interface MergeResult {
+  merged: MergedCompose;
+  conflicts: ComposeConflict[];
+}
+
+export interface ComposeAggregator {
+  discover(servicePaths: string[]): DiscoveredCompose[];
+  merge(composes: DiscoveredCompose[]): MergeResult;
+}
+
+/** Extract host ports from a compose service ports definition */
+function extractHostPorts(ports: any[]): string[] {
+  const result: string[] = [];
+  for (const p of ports) {
+    const portStr = typeof p === 'object' && p.published != null
+      ? String(p.published)
+      : String(p);
+    // Match host port from formats like "8080:80", "127.0.0.1:8080:80", "8080:80/tcp"
+    const match = portStr.match(/(?:[\d.]+:)?(\d+):\d+/);
+    if (match) result.push(match[1]);
+  }
+  return result;
+}
+
+export function createComposeAggregator(): ComposeAggregator {
+  return {
+    discover(servicePaths: string[]): DiscoveredCompose[] {
+      const results: DiscoveredCompose[] = [];
+      for (const svcPath of servicePaths) {
+        const composePath = join(svcPath, 'docker-compose.yml');
+        if (!existsSync(composePath)) continue;
+        const raw = readFileSync(composePath, 'utf-8');
+        const content = (parse(raw) ?? {}) as DockerComposeDocument;
+        const serviceName = svcPath.split('/').pop() ?? svcPath;
+        results.push({ serviceName, path: composePath, content });
+      }
+      return results;
+    },
+
+    merge(composes: DiscoveredCompose[]): MergeResult {
+      const merged: MergedCompose = { services: {}, networks: {}, volumes: {} };
+      const conflicts: ComposeConflict[] = [];
+
+      // Track origins for conflict detection
+      const serviceOrigins = new Map<string, string[]>();
+      const portOrigins = new Map<string, string[]>();
+
+      for (const compose of composes) {
+        const { content, path: sourcePath } = compose;
+        if (!content) continue;
+
+        // Merge services
+        if (content.services) {
+          for (const [name, def] of Object.entries(content.services)) {
+            if (!serviceOrigins.has(name)) serviceOrigins.set(name, []);
+            serviceOrigins.get(name)!.push(sourcePath);
+
+            // Detect port conflicts
+            if (def?.ports && Array.isArray(def.ports)) {
+              for (const hostPort of extractHostPorts(def.ports)) {
+                const key = hostPort;
+                if (!portOrigins.has(key)) portOrigins.set(key, []);
+                portOrigins.get(key)!.push(sourcePath);
+              }
+            }
+
+            // First definition wins (deterministic)
+            if (!merged.services[name]) {
+              merged.services[name] = def;
+            }
+          }
+        }
+
+        // Merge networks
+        if (content.networks) {
+          for (const [name, def] of Object.entries(content.networks)) {
+            if (!merged.networks[name]) {
+              merged.networks[name] = def;
+            }
+          }
+        }
+
+        // Merge volumes
+        if (content.volumes) {
+          for (const [name, def] of Object.entries(content.volumes)) {
+            if (!merged.volumes[name]) {
+              merged.volumes[name] = def;
+            }
+          }
+        }
+      }
+
+      // Report service name conflicts
+      for (const [name, sources] of serviceOrigins) {
+        if (sources.length > 1) {
+          conflicts.push({
+            type: 'service_name',
+            sources,
+            description: `Service "${name}" declared in multiple compose files`,
+          });
+        }
+      }
+
+      // Report port conflicts
+      for (const [port, sources] of portOrigins) {
+        if (sources.length > 1) {
+          conflicts.push({
+            type: 'port',
+            sources,
+            description: `Host port ${port} mapped in multiple compose files`,
+          });
+        }
+      }
+
+      return { merged, conflicts };
+    },
+  };
+}

package/src/infra/compose-smart-merger.ts

@@ -0,0 +1,93 @@
+import { Ollama } from 'ollama';
+import { z } from 'zod';
+import { createComposeAggregator, type DiscoveredCompose, type MergedCompose } from './compose-aggregator.js';
+import { logger } from '../shared/logger.js';
+
+/** Zod schema to validate LLM output */
+const MergedComposeSchema = z.object({
+  services: z.record(z.string(), z.any()).default({}),
+  networks: z.record(z.string(), z.any()).default({}),
+  volumes: z.record(z.string(), z.any()).default({}),
+});
+
+export interface ComposeSmartMerger {
+  deduplicate(composes: DiscoveredCompose[]): Promise<MergedCompose>;
+}
+
+/** Build the structured prompt for Phi-4 */
+function buildPrompt(composes: DiscoveredCompose[]): string {
+  const composesText = composes
+    .map((c) => `--- ${c.serviceName} (${c.path}) ---\n${JSON.stringify(c.content, null, 2)}`)
+    .join('\n\n');
+
+  return `You are a Docker Compose expert. Given multiple docker-compose files from different services, merge them into a single unified compose file.
+
+Rules:
+1. Deduplicate containers that represent the same infrastructure (e.g. multiple postgres definitions → keep one)
+2. When images differ, prefer the most recent version
+3. Merge all environment variables from duplicates without losing any
+4. Consolidate networks and volumes, removing redundancies
+5. Preserve all port mappings, flagging conflicts if any
+
+Input compose files:
+${composesText}
+
+Return ONLY valid JSON with this exact structure:
+{"services": {...}, "networks": {...}, "volumes": {...}}`;
+}
+
+/** Check if Ollama is available with phi4 model */
+async function isOllamaAvailable(client: Ollama): Promise<boolean> {
+  try {
+    const models = await client.list();
+    return models.models.some((m) => m.name.startsWith('phi4'));
+  } catch {
+    return false;
+  }
+}
+
+export function createComposeSmartMerger(): ComposeSmartMerger {
+  const client = new Ollama();
+  const aggregator = createComposeAggregator();
+
+  return {
+    async deduplicate(composes: DiscoveredCompose[]): Promise<MergedCompose> {
+      if (composes.length === 0) {
+        return { services: {}, networks: {}, volumes: {} };
+      }
+
+      // Try LLM-based merge
+      if (await isOllamaAvailable(client)) {
+        try {
+          logger.info('Usando Phi-4 para merge inteligente de compose files...');
+          const prompt = buildPrompt(composes);
+          const response = await client.generate({
+            model: 'phi4',
+            prompt,
+            format: 'json',
+            stream: false,
+          });
+
+          const parsed = JSON.parse(response.response);
+          const validated = MergedComposeSchema.safeParse(parsed);
+
+          if (validated.success) {
+            logger.info('Merge inteligente concluído com sucesso.');
+            return validated.data;
+          }
+
+          logger.warn('Output da LLM falhou na validação Zod. Usando fallback determinístico.');
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          logger.warn(`Erro ao usar Phi-4: ${msg}. Usando fallback determinístico.`);
+        }
+      } else {
+        logger.info('Ollama/Phi-4 indisponível. Usando merge determinístico.');
+      }
+
+      // Fallback: deterministic merge
+      const { merged } = aggregator.merge(composes);
+      return merged;
+    },
+  };
+}

package/src/infra/infra-manager.ts

@@ -0,0 +1,157 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { stringify } from 'yaml';
+import { run } from '../shared/process-runner.js';
+import { logger } from '../shared/logger.js';
+import { OctoError } from '../shared/errors.js';
+import { createComposeSmartMerger } from './compose-smart-merger.js';
+import { createComposeAggregator, type MergedCompose } from './compose-aggregator.js';
+
+export type ContainerState = 'running' | 'stopped' | 'unhealthy';
+
+export interface ContainerStatus {
+  name: string;
+  image: string;
+  state: ContainerState;
+  port: string;
+}
+
+export interface InfraResult {
+  success: boolean;
+  message: string;
+}
+
+export interface InfraManager {
+  up(services?: string[]): Promise<InfraResult>;
+  down(options: { volumes?: boolean }): Promise<InfraResult>;
+  status(): Promise<ContainerStatus[]>;
+}
+
+const HEALTHCHECK_TIMEOUT_MS = 60_000;
+const HEALTHCHECK_POLL_MS = 2_000;
+
+/** Write merged compose to a temp file and return its path */
+async function writeTempCompose(merged: MergedCompose): Promise<string> {
+  const tempPath = join(tmpdir(), `octo-compose-${Date.now()}.yml`);
+  const content = stringify(merged);
+  await writeFile(tempPath, content, 'utf-8');
+  return tempPath;
+}
+
+/** Poll healthcheck for a container, returns true if healthy within timeout */
+async function waitForHealthcheck(containerName: string): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < HEALTHCHECK_TIMEOUT_MS) {
+    const result = await run('docker', [
+      'inspect', '--format', '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}', containerName,
+    ]);
+    const status = result.stdout.trim();
+    if (status === 'healthy' || status === 'none') return true;
+    if (status === 'unhealthy') return false;
+    await new Promise((r) => setTimeout(r, HEALTHCHECK_POLL_MS));
+  }
+  return false;
+}
+
+/** Show last 20 lines of container log */
+async function showContainerLogs(containerName: string): Promise<void> {
+  const result = await run('docker', ['logs', '--tail', '20', containerName]);
+  const output = result.stdout || result.stderr;
+  if (output) logger.error(`Últimas 20 linhas de log (${containerName}):\n${output}`);
+}
+
+export function createInfraManager(servicePaths: string[]): InfraManager {
+  const aggregator = createComposeAggregator();
+  const smartMerger = createComposeSmartMerger();
+  let composePath: string | undefined;
+
+  return {
+    async up(services?: string[]): Promise<InfraResult> {
+      const paths = services && services.length > 0
+        ? servicePaths.filter((p) => services.some((s) => p.endsWith(s)))
+        : servicePaths;
+
+      const discovered = aggregator.discover(paths);
+      if (discovered.length === 0) {
+        return { success: true, message: 'Nenhum docker-compose.yml encontrado.' };
+      }
+
+      logger.info(`Descobertos ${discovered.length} compose file(s). Merging...`);
+      const merged = await smartMerger.deduplicate(discovered);
+      composePath = await writeTempCompose(merged);
+
+      logger.info('Subindo containers...');
+      const result = await run('docker', ['compose', '-f', composePath, 'up', '-d']);
+      if (result.exitCode !== 0) {
+        return { success: false, message: `docker compose up falhou: ${result.stderr}` };
+      }
+
+      // Wait for healthchecks
+      const serviceNames = Object.keys(merged.services);
+      for (const svc of serviceNames) {
+        const healthy = await waitForHealthcheck(svc);
+        if (!healthy) {
+          logger.error(`Healthcheck timeout para container "${svc}".`);
+          await showContainerLogs(svc);
+          // Stop dependents but don't tear down everything
+          return { success: false, message: `Healthcheck timeout: ${svc}` };
+        }
+      }
+
+      return { success: true, message: `${serviceNames.length} container(s) iniciado(s).` };
+    },
+
+    async down(options: { volumes?: boolean }): Promise<InfraResult> {
+      // Discover and merge to get the compose file path
+      if (!composePath) {
+        const discovered = aggregator.discover(servicePaths);
+        if (discovered.length === 0) {
+          return { success: true, message: 'Nenhum container para parar.' };
+        }
+        const merged = await smartMerger.deduplicate(discovered);
+        composePath = await writeTempCompose(merged);
+      }
+
+      const args = ['compose', '-f', composePath, 'down'];
+      if (options.volumes) args.push('--volumes');
+
+      const result = await run('docker', args);
+      if (result.exitCode !== 0) {
+        return { success: false, message: `docker compose down falhou: ${result.stderr}` };
+      }
+
+      return { success: true, message: 'Containers parados.' };
+    },
+
+    async status(): Promise<ContainerStatus[]> {
+      if (!composePath) {
+        const discovered = aggregator.discover(servicePaths);
+        if (discovered.length === 0) return [];
+        const merged = await smartMerger.deduplicate(discovered);
+        composePath = await writeTempCompose(merged);
+      }
+
+      const result = await run('docker', ['compose', '-f', composePath, 'ps', '--format', 'json']);
+      if (result.exitCode !== 0 || !result.stdout.trim()) return [];
+
+      const containers: ContainerStatus[] = [];
+      // docker compose ps --format json outputs one JSON object per line
+      for (const line of result.stdout.trim().split('\n')) {
+        try {
+          const entry = JSON.parse(line);
+          const state: ContainerState =
+            entry.Health === 'unhealthy' ? 'unhealthy' :
+            entry.State === 'running' ? 'running' : 'stopped';
+          containers.push({
+            name: entry.Name ?? entry.Service ?? '',
+            image: entry.Image ?? '',
+            state,
+            port: entry.Publishers?.map((p: any) => `${p.PublishedPort}:${p.TargetPort}`).join(', ') ?? '',
+          });
+        } catch { /* skip malformed lines */ }
+      }
+      return containers;
+    },
+  };
+}

package/src/manifest/manifest-discovery.ts

@@ -0,0 +1,144 @@
+import { readdirSync, statSync, existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { ManifestError } from '../shared/errors.js';
+import { logger } from '../shared/logger.js';
+
+const MANIFEST_FILENAME = 'octo.yaml';
+const MAX_DEPTH = 5;
+const SKIP_DIRS = new Set(['node_modules', 'dist']);
+
+export interface DiscoveredManifest {
+  name: string;
+  path: string;
+  isRoot: boolean;
+}
+
+/** Checks if a directory name should be skipped during scan */
+function shouldSkip(dirName: string): boolean {
+  return dirName.startsWith('.') || SKIP_DIRS.has(dirName);
+}
+
+/**
+ * Recursively scans directories for octo.yaml files.
+ * Skips node_modules, dist, and dot-prefixed directories.
+ * Max scan depth: 5 levels.
+ */
+function scanForManifests(dir: string, rootDir: string, depth: number): DiscoveredManifest[] {
+  if (depth > MAX_DEPTH) return [];
+
+  const results: DiscoveredManifest[] = [];
+  const manifestPath = join(dir, MANIFEST_FILENAME);
+
+  if (existsSync(manifestPath)) {
+    const dirName = relative(rootDir, dir) || '.';
+    results.push({
+      name: dirName === '.' ? 'root' : dirName,
+      path: manifestPath,
+      isRoot: dir === rootDir,
+    });
+  }
+
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return results;
+  }
+
+  for (const entry of entries) {
+    if (shouldSkip(entry)) continue;
+    const fullPath = join(dir, entry);
+    try {
+      if (statSync(fullPath).isDirectory()) {
+        results.push(...scanForManifests(fullPath, rootDir, depth + 1));
+      }
+    } catch {
+      // Skip inaccessible entries
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Discovers all octo.yaml manifests starting from rootDir.
+ * If a root manifest exists alongside sub-manifests, prioritizes root.
+ */
+export function discoverManifests(rootDir: string): DiscoveredManifest[] {
+  const all = scanForManifests(rootDir, rootDir, 0);
+
+  // If root manifest exists, filter out sub-manifests already referenced
+  const rootManifest = all.find((m) => m.isRoot);
+  if (rootManifest && all.length > 1) {
+    // Prioritize root — return only root manifest
+    return [rootManifest];
+  }
+
+  return all;
+}
+
+/**
+ * Resolves execution mode based on manifest discovery.
+ * - standalone: exactly one octo.yaml in execution dir, no sub-manifests
+ * - aggregated: multiple octo.yaml files in subdirectories
+ */
+export function resolveMode(rootDir: string): 'standalone' | 'aggregated' {
+  const all = scanForManifests(rootDir, rootDir, 0);
+  const rootManifest = all.find((m) => m.isRoot);
+  const subManifests = all.filter((m) => !m.isRoot);
+
+  // Root manifest with sub-manifests → standalone (root takes priority)
+  if (rootManifest && subManifests.length > 0) {
+    return 'standalone';
+  }
+
+  // Exactly one manifest in execution dir → standalone
+  if (rootManifest && subManifests.length === 0) {
+    return 'standalone';
+  }
+
+  // Multiple sub-manifests without root → aggregated
+  if (subManifests.length > 1) {
+    return 'aggregated';
+  }
+
+  // Single sub-manifest → standalone
+  return 'standalone';
+}
+
+/**
+ * Detects name collisions across discovered manifests.
+ * Throws ManifestError if two manifests declare the same service/package name.
+ */
+export function detectNameCollisions(manifests: DiscoveredManifest[]): void {
+  const seen = new Map<string, string>(); // name → path
+
+  for (const manifest of manifests) {
+    if (seen.has(manifest.name)) {
+      const existing = seen.get(manifest.name)!;
+      throw new ManifestError(
+        `Name collision detected: "${manifest.name}" declared in both "${existing}" and "${manifest.path}"`,
+      );
+    }
+    seen.set(manifest.name, manifest.path);
+  }
+}
+
+/**
+ * Displays discovered projects in aggregated mode.
+ * Called at the beginning of execution when in aggregated mode.
+ */
+export function displayDiscoveredProjects(rootDir: string): DiscoveredManifest[] {
+  const manifests = discoverManifests(rootDir);
+  const mode = resolveMode(rootDir);
+
+  if (mode === 'aggregated') {
+    logger.info(`Modo agregado: ${manifests.length} projetos descobertos`);
+    for (const m of manifests) {
+      logger.info(`  → ${m.name} (${relative(rootDir, m.path)})`);
+    }
+  }
+
+  detectNameCollisions(manifests);
+  return manifests;
+}