octo-dev 0.7.2 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octo-dev",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "Build orchestration, semantic versioning, and local infrastructure management for repository workspaces",
   "type": "module",
   "license": "MIT",
@@ -43,9 +43,12 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
+    "ai": "^6.0.194",
+    "@ai-sdk/openai": "^3.0.67",
+    "@ai-sdk/google": "^3.0.80",
+    "@ai-sdk/anthropic": "^3.0.81",
     "commander": "^13.1.0",
     "execa": "^9.6.1",
-    "@huggingface/transformers": "^4.2.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
     "semver": "^7.7.2",

package/src/cli/config.command.ts

@@ -1,10 +1,22 @@
 import { run } from '../shared/process-runner.js';
 import { logger } from '../shared/logger.js';
+import { saveConfig, getConfigPath, type LlmConfig } from '../shared/config.js';
+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' },
+  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: '' },
+};
 
 /**
- * octo config git-cache
+ * octo config git-cache [value]
+ *
+ * Sets git credential.helper locally.
  *
- * Enables git credential cache locally.
+ * @param value - The credential helper value (default: "cache").
  */
 export async function configGitCacheCommand(value?: string): Promise<void> {
   const helper = value || 'cache';
@@ -15,3 +27,38 @@ export async function configGitCacheCommand(value?: string): Promise<void> {
   }
   logger.info(`Git credential.helper set to "${helper}".`);
 }
+
+/**
+ * octo config llm
+ *
+ * Configures the LLM provider interactively.
+ * Stores api key and provider settings in ~/.octo-config.json.
+ */
+export async function configLlmCommand(): Promise<void> {
+  const providerNames = Object.keys(PROVIDERS);
+  logger.info(`Available providers: ${providerNames.join(', ')}`);
+
+  const provider = await ask('Provider: ');
+  if (!providerNames.includes(provider)) {
+    logger.error(`Unknown provider "${provider}". Available: ${providerNames.join(', ')}`);
+    return;
+  }
+
+  const preset = PROVIDERS[provider];
+  const baseUrl = provider === 'custom'
+    ? await ask('Base URL (OpenAI-compatible): ')
+    : preset.baseUrl;
+
+  const model = await ask(`Model [${preset.defaultModel}]: `) || preset.defaultModel;
+  const apiKey = await askSecret('API key: ');
+
+  if (!apiKey) {
+    logger.error('API key is required.');
+    return;
+  }
+
+  const llm: LlmConfig = { provider, baseUrl, model, apiKey };
+  saveConfig({ llm });
+
+  logger.info(`LLM configured (${provider}/${model}). Saved to ${getConfigPath()}`);
+}

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.7.2');
+  .version('0.8.1');
 
 program
   .command('init')
@@ -106,4 +106,12 @@ config
     await configGitCacheCommand(value);
   });
 
+config
+  .command('llm')
+  .description('Configure LLM provider (openai, gemini, groq, anthropic, custom)')
+  .action(async () => {
+    const { configLlmCommand } = await import('./config.command.js');
+    await configLlmCommand();
+  });
+
 program.parse();

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,46 +11,59 @@ 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: {} };
       }
 
       // Try LLM-based merge
-      if (await isAvailable()) {
+      if (isAvailable()) {
         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}.`,
         };
       }
 

package/src/shared/config.ts

@@ -0,0 +1,50 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CONFIG_FILE = join(homedir(), '.octo-config.json');
+
+export interface LlmConfig {
+  provider: string;
+  baseUrl: string;
+  model: string;
+  apiKey: string;
+}
+
+export interface OctoConfig {
+  llm?: LlmConfig;
+}
+
+/**
+ * Loads the octo configuration from ~/.octo-config.json.
+ * Returns an empty config object if the file doesn't exist or is invalid.
+ *
+ * @returns The parsed configuration.
+ */
+export function loadConfig(): OctoConfig {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8')) as OctoConfig;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Saves the octo configuration to ~/.octo-config.json.
+ * Merges with existing config (does not overwrite unrelated keys).
+ *
+ * @param partial - Partial config to merge and persist.
+ */
+export function saveConfig(partial: Partial<OctoConfig>): void {
+  const existing = loadConfig();
+  const merged = { ...existing, ...partial };
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), 'utf-8');
+}
+
+/**
+ * Returns the path to the config file for display purposes.
+ */
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}

package/src/shared/llm.ts

@@ -1,69 +1,78 @@
-import { pipeline, type TextGenerationPipeline } from '@huggingface/transformers';
+import { generateText } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createAnthropic } from '@ai-sdk/anthropic';
 import { logger } from './logger.js';
-
-const MODEL_ID = 'onnx-community/Qwen2.5-0.5B-Instruct';
-
-let generator: TextGenerationPipeline | null = null;
-let initFailed = false;
+import { loadConfig, type LlmConfig } from './config.js';
 
 /**
- * Lazily initializes the text generation pipeline.
- * Downloads the ONNX model on first use (~500MB, cached locally).
+ * Resolves the AI SDK language model from the stored config.
+ * Supports openai, gemini, groq, anthropic, and any OpenAI-compatible custom endpoint.
+ *
+ * @param config - The LLM configuration with provider, baseUrl, model, and apiKey.
+ * @returns An AI SDK language model instance.
  */
-async function getGenerator(): Promise<TextGenerationPipeline | null> {
-  if (initFailed) return null;
-  if (generator) return generator;
-
-  try {
-    logger.info('Loading local AI model (first run may take a while)...');
-    generator = await pipeline('text-generation', MODEL_ID, {
-      dtype: 'q4',
-    }) as TextGenerationPipeline;
-    return generator;
-  } catch (err) {
-    initFailed = true;
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.info(`Local AI model unavailable: ${msg}. Using deterministic fallback.`);
-    return null;
+function resolveModel(config: LlmConfig) {
+  switch (config.provider) {
+    case 'google':
+    case 'gemini': {
+      const google = createGoogleGenerativeAI({ apiKey: config.apiKey });
+      return google(config.model);
+    }
+    case 'anthropic': {
+      const anthropic = createAnthropic({ apiKey: config.apiKey });
+      return anthropic(config.model);
+    }
+    case 'openai':
+    case 'groq':
+    case 'custom':
+    default: {
+      const openai = createOpenAI({ apiKey: config.apiKey, baseURL: config.baseUrl });
+      return openai(config.model);
+    }
   }
 }
 
 /**
- * Generates text from a prompt using the local ONNX model.
- * Returns null if the model is unavailable or generation fails.
+ * Generates text from a prompt using the configured LLM provider.
+ * Returns null if no LLM is configured or the request fails.
+ *
+ * @param prompt - The user prompt to send.
+ * @param maxTokens - Maximum tokens in the response.
+ * @returns The generated text, or null on failure.
  */
 export async function generate(prompt: string, maxTokens = 512): Promise<string | null> {
-  const gen = await getGenerator();
-  if (!gen) return null;
+  const config = loadConfig();
+  if (!config.llm?.apiKey) return null;
 
   try {
-    const messages = [
-      { role: 'user', content: prompt },
-    ];
-    const result = await gen(messages, {
-      max_new_tokens: maxTokens,
-      do_sample: false,
+    const model = resolveModel(config.llm);
+    const { text } = await generateText({
+      model,
+      prompt,
+      maxTokens,
+      temperature: 0,
     });
-    const output = result[0]?.generated_text;
-    if (Array.isArray(output)) {
-      const last = output[output.length - 1];
-      return typeof last === 'object' && 'content' in last ? String(last.content) : null;
-    }
-    return typeof output === 'string' ? output : null;
-  } catch {
+    return text?.trim() || null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`LLM request failed: ${msg}. Using deterministic fallback.`);
     return null;
   }
 }
 
 /**
  * Generates structured JSON output from a prompt.
- * Returns null if parsing fails or model is unavailable.
+ * Returns null if parsing fails or LLM is unavailable.
+ *
+ * @param prompt - The prompt requesting JSON output.
+ * @param maxTokens - Maximum tokens in the response.
+ * @returns Parsed JSON object, or null on failure.
  */
 export async function generateJSON<T = unknown>(prompt: string, maxTokens = 1024): Promise<T | null> {
   const text = await generate(prompt, maxTokens);
   if (!text) return null;
 
-  // Extract JSON from the response (model may wrap in markdown code blocks)
   const jsonMatch = text.match(/\{[\s\S]*\}/);
   if (!jsonMatch) return null;
 
@@ -75,9 +84,11 @@ export async function generateJSON<T = unknown>(prompt: string, maxTokens = 1024
 }
 
 /**
- * Checks if the LLM is available (model loaded or loadable).
+ * Checks if an LLM provider is configured.
+ *
+ * @returns true if LLM config exists with a valid apiKey.
  */
-export async function isAvailable(): Promise<boolean> {
-  const gen = await getGenerator();
-  return gen !== null;
+export function isAvailable(): boolean {
+  const config = loadConfig();
+  return !!config.llm?.apiKey;
 }