octo-dev 0.8.0 → 0.8.1

package/package.json

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

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.8.1');
 
 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.
+ * Instructs the model to unify redundant infrastructure (databases, caches, brokers)
+ * into shared instances while preserving application-specific services.
+ *
+ * @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 a Docker Compose optimization expert. Given multiple docker-compose files from a workspace of microservices, produce the most optimized unified compose possible.
 
-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 goals (in priority order):
+1. UNIFY shared infrastructure — multiple PostgreSQL, Redis, MongoDB, Elasticsearch, RabbitMQ, NATS, or similar containers MUST be consolidated into a single shared instance. Create separate databases/schemas via environment variables or init scripts, not separate containers.
+2. UNIFY shared volumes — if multiple services mount the same type of volume (e.g. pg-data), consolidate into one.
+3. UNIFY networks — use a single shared network unless isolation is explicitly required for security.
+4. PRESERVE application services — each microservice container remains separate (they are distinct apps).
+5. MERGE environment variables — when unifying databases, collect all required databases/users into the shared instance config.
+6. AVOID port conflicts — if two services expose the same host port, remap one to an available port.
+7. USE latest image versions when duplicates exist with different tags.
+8. ADD healthchecks to infrastructure services (postgres, redis, etc.) if not already present.
+9. ADD depends_on with condition: service_healthy for app services that need infrastructure.
+
+Example: If service-a has postgres:16 on port 5432 and service-b has postgres:15 on port 5433, produce ONE postgres:16 container with both databases created via POSTGRES_MULTIPLE_DATABASES env or an init script volume.
 
 Input compose files:
 ${composesText}
 
 Return ONLY valid JSON with this exact structure:
-{"services": {...}, "networks": {...}, "volumes": {...}}`;
+{"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}.`,
         };
       }