octo-dev 0.7.1 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octo-dev",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "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.1');
+  .version('0.8.0');
 
 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-smart-merger.ts

@@ -46,7 +46,7 @@ export function createComposeSmartMerger(): ComposeSmartMerger {
       }
 
       // Try LLM-based merge
-      if (await isAvailable()) {
+      if (isAvailable()) {
         try {
           logger.info('Using local AI for smart compose merge...');
           const prompt = buildPrompt(composes);

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/git-auth.ts

@@ -1,17 +1,17 @@
-import { ask } from './prompt.js';
+import { askSecret } from './prompt.js';
 
 let cachedToken: string | undefined;
 
 /**
  * Acquires a GitHub Personal Access Token for git HTTPS operations.
- * Prompts the user once and caches in memory for the process lifetime.
- * The token is never persisted to disk.
+ * Prompts the user once (input hidden) and caches in memory for the process lifetime.
+ * The token is never persisted to disk or echoed to the terminal.
  *
  * @returns The PAT string, or undefined if the user provides empty input (skip).
  */
 export async function acquireGitToken(): Promise<string | undefined> {
   if (cachedToken) return cachedToken;
-  const input = await ask('GitHub token (PAT): ');
+  const input = await askSecret('GitHub token (PAT): ');
   cachedToken = input || undefined;
   return cachedToken;
 }

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;
 }

package/src/shared/prompt.ts

@@ -16,6 +16,47 @@ export function ask(message: string): Promise<string> {
   });
 }
 
+/**
+ * Prompts the user for sensitive input (e.g. tokens, passwords).
+ * Input is not echoed to the terminal.
+ *
+ * @param message - The prompt message displayed to the user.
+ * @returns The trimmed secret string.
+ */
+export function askSecret(message: string): Promise<string> {
+  return new Promise((resolve) => {
+    process.stdout.write(message);
+
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf-8');
+
+    let input = '';
+
+    const onData = (char: string) => {
+      if (char === '\n' || char === '\r') {
+        stdin.removeListener('data', onData);
+        if (stdin.isTTY) stdin.setRawMode(wasRaw ?? false);
+        stdin.pause();
+        process.stdout.write('\n');
+        resolve(input.trim());
+      } else if (char === '\u0003') {
+        // Ctrl+C
+        process.exit(130);
+      } else if (char === '\u007F' || char === '\b') {
+        // Backspace
+        input = input.slice(0, -1);
+      } else {
+        input += char;
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}
+
 /**
  * Prompts the user with a yes/no question via stdin.
  * Accepts 'y', 'Y', 's', 'S' as affirmative responses.

package/src/shared/sync.ts

@@ -25,7 +25,7 @@ export async function ensureRepositories(manifest: OctoManifest, rootDir: string
 
   if (pending.length === 0) return 0;
 
-  logger.info(`${pending.length} repository(ies) to clone.`);
+  logger.info(`${pending.length} repository(ies) to clone.\n`);
 
   // Acquire token once for all clones
   const token = await acquireGitToken();