octo-dev 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octo-dev",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Build orchestration, semantic versioning, and local infrastructure management for repository workspaces",
   "type": "module",
   "license": "MIT",

package/src/cli/config.command.ts

@@ -5,7 +5,7 @@ import { ask, askSecret } from '../shared/prompt.js';
 
 const PROVIDERS: Record<string, { baseUrl: string; defaultModel: string }> = {
   openai: { baseUrl: 'https://openai.com/v1', defaultModel: 'gpt-4o-mini' },
-  gemini: { baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai', defaultModel: 'gemini-2.0-flash' },
+  gemini: { baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai', defaultModel: 'gemini-2.5-flash' },
   groq: { baseUrl: 'https://api.groq.com/openai/v1', defaultModel: 'llama-3.3-70b-versatile' },
   anthropic: { baseUrl: 'https://api.anthropic.com/v1', defaultModel: 'claude-sonnet-4-20250514' },
   custom: { baseUrl: '', defaultModel: '' },

package/src/cli/index.ts

@@ -11,7 +11,7 @@ const program = new Command();
 program
   .name('octo')
   .description('Build orchestration, semantic versioning, and local infrastructure management for repository workspaces')
-  .version('0.8.0');
+  .version('0.9.0');
 
 program
   .command('init')

package/src/infra/compose-aggregator.ts

@@ -1,5 +1,5 @@
 import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, dirname, relative } from 'node:path';
 import { parse } from 'yaml';
 
 /** A discovered docker-compose.yml from a service directory */
@@ -39,7 +39,33 @@ export interface MergeResult {
 
 export interface ComposeAggregator {
   discover(servicePaths: string[]): DiscoveredCompose[];
-  merge(composes: DiscoveredCompose[]): MergeResult;
+  merge(composes: DiscoveredCompose[], rootDir: string): MergeResult;
+}
+
+/**
+ * Rewrites the `build` field of a service definition to be relative to rootDir.
+ * Handles both string format (`build: .`) and object format (`build: { context: ./src }`).
+ *
+ * @param def - The service definition object.
+ * @param composeDir - The directory containing the original compose file.
+ * @param rootDir - The workspace root where the merged compose will be written.
+ * @returns The service definition with corrected build paths.
+ */
+function rewriteBuildPath(def: any, composeDir: string, rootDir: string): any {
+  if (!def?.build) return def;
+
+  const rewritten = { ...def };
+
+  if (typeof rewritten.build === 'string') {
+    const absolutePath = join(composeDir, rewritten.build);
+    rewritten.build = `./${relative(rootDir, absolutePath)}`;
+  } else if (typeof rewritten.build === 'object') {
+    const context = rewritten.build.context ?? '.';
+    const absolutePath = join(composeDir, context);
+    rewritten.build = { ...rewritten.build, context: `./${relative(rootDir, absolutePath)}` };
+  }
+
+  return rewritten;
 }
 
 /** Extract host ports from a compose service ports definition */
@@ -71,11 +97,10 @@ export function createComposeAggregator(): ComposeAggregator {
       return results;
     },
 
-    merge(composes: DiscoveredCompose[]): MergeResult {
+    merge(composes: DiscoveredCompose[], rootDir: string): 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[]>();
 
@@ -83,12 +108,16 @@ export function createComposeAggregator(): ComposeAggregator {
         const { content, path: sourcePath } = compose;
         if (!content) continue;
 
+        const composeDir = dirname(sourcePath);
+
         // Merge services
         if (content.services) {
-          for (const [name, def] of Object.entries(content.services)) {
+          for (const [name, rawDef] of Object.entries(content.services)) {
             if (!serviceOrigins.has(name)) serviceOrigins.set(name, []);
             serviceOrigins.get(name)!.push(sourcePath);
 
+            const def = rewriteBuildPath(rawDef, composeDir, rootDir);
+
             // Detect port conflicts
             if (def?.ports && Array.isArray(def.ports)) {
               for (const hostPort of extractHostPorts(def.ports)) {

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

@@ -11,36 +11,49 @@ const MergedComposeSchema = z.object({
 });
 
 export interface ComposeSmartMerger {
-  deduplicate(composes: DiscoveredCompose[]): Promise<MergedCompose>;
+  deduplicate(composes: DiscoveredCompose[], rootDir: string): Promise<MergedCompose>;
 }
 
-/** Build the structured prompt */
+/**
+ * Builds the LLM prompt for optimized compose merging.
+ * The prompt is agnostic — it describes optimization principles without
+ * referencing specific technologies or project names.
+ *
+ * @param composes - Array of discovered compose files to merge.
+ * @returns The formatted prompt string.
+ */
 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.
+  return `You are given multiple docker-compose files from a workspace of microservices. Produce a single optimized unified docker-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
+Optimization principles:
+
+- Infrastructure consolidation: when multiple services declare separate containers of the same database engine (e.g. multiple PostgreSQL instances), consolidate them into a single shared instance that hosts multiple databases. The same applies to message brokers, caches, search engines, and any other shared infrastructure.
+
+- Application preservation: each application service (containers with a "build" directive) must remain as a separate container. Never merge application services together.
+
+- Dependency correctness: update all environment variables in application services to point to the consolidated infrastructure container names. Ensure depends_on references the correct unified containers with condition: service_healthy.
+
+- Minimal resource footprint: use one shared network, one volume per infrastructure type, and eliminate any redundant declarations.
+
+- Healthchecks: every infrastructure container must have a healthcheck defined.
+
+- Port conflicts: if consolidation would create port conflicts on the host, remap to available ports.
 
 Input compose files:
 ${composesText}
 
-Return ONLY valid JSON with this exact structure:
-{"services": {...}, "networks": {...}, "volumes": {...}}`;
+Return ONLY valid JSON with this structure: {"services": {...}, "networks": {...}, "volumes": {...}}`
 }
 
 export function createComposeSmartMerger(): ComposeSmartMerger {
   const aggregator = createComposeAggregator();
 
   return {
-    async deduplicate(composes: DiscoveredCompose[]): Promise<MergedCompose> {
+    async deduplicate(composes: DiscoveredCompose[], rootDir: string): Promise<MergedCompose> {
       if (composes.length === 0) {
         return { services: {}, networks: {}, volumes: {} };
       }
@@ -50,7 +63,7 @@ export function createComposeSmartMerger(): ComposeSmartMerger {
         try {
           logger.info('Using local AI for smart compose merge...');
           const prompt = buildPrompt(composes);
-          const parsed = await generateJSON(prompt);
+          const parsed = await generateJSON(prompt, 4096);
 
           if (parsed) {
             const validated = MergedComposeSchema.safeParse(parsed);
@@ -69,7 +82,7 @@ export function createComposeSmartMerger(): ComposeSmartMerger {
       }
 
       // Fallback: deterministic merge
-      const { merged } = aggregator.merge(composes);
+      const { merged } = aggregator.merge(composes, rootDir);
       return merged;
     },
   };

package/src/infra/infra-manager.ts

@@ -164,7 +164,7 @@ async function resolveComposePath(
   }
 
   logger.info(`Found ${discovered.length} compose files with changes — merging into unified docker-compose.yml`);
-  const merged = await smartMerger.deduplicate(discovered);
+  const merged = await smartMerger.deduplicate(discovered, rootDir);
   const outputPath = await writeMergedCompose(merged, rootDir);
   await writeChecksum(rootDir, currentChecksum);
   return outputPath;
@@ -205,11 +205,14 @@ export function createInfraManager(servicePaths: string[], rootDir: string): Inf
       const composePath = await resolveComposePath(discovered, rootDir, smartMerger);
 
       logger.info('Starting containers with docker compose...');
-      const result = await run('docker', ['compose', '-f', composePath, 'up', '-d']);
+      const result = await run('docker', ['compose', '-f', composePath, 'up', '-d', '--build'], {
+        timeout: 600_000,
+        interactive: true,
+      });
       if (result.exitCode !== 0) {
         return {
           success: false,
-          message: `Failed to start containers. docker compose exited with code ${result.exitCode}:\n${result.stderr.trim()}`,
+          message: `Failed to start containers. docker compose exited with code ${result.exitCode}.`,
         };
       }