octo-dev 0.4.3 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octo-dev",
-  "version": "0.4.3",
+  "version": "0.5.2",
   "description": "CLI for monorepo build orchestration, semantic versioning, and local infrastructure management",
   "type": "module",
   "license": "MIT",
@@ -45,7 +45,9 @@
   "dependencies": {
     "commander": "^13.1.0",
     "execa": "^9.6.1",
-    "ollama": "^0.5.16",
+    "@huggingface/transformers": "^4.2.0",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
     "semver": "^7.7.2",
     "tsx": "^4.19.4",
     "yaml": "^2.7.1",

package/src/build/build-orchestrator.ts

@@ -48,13 +48,13 @@ export function createBuildOrchestrator(): BuildOrchestrator {
       const inProgress = lastProgress.filter((p) => p.status === 'building');
       const pending = lastProgress.filter((p) => p.status === 'pending');
       logger.info(
-        `Estado parcial: ${completed.length} concluídos, ${inProgress.length} em andamento, ${pending.length} pendentes`,
+        `Partial state: ${completed.length} completed, ${inProgress.length} in progress, ${pending.length} pending`,
       );
       if (completed.length > 0) {
-        logger.info(`  Concluídos: ${completed.map((p) => p.service).join(', ')}`);
+        logger.info(`  Completed: ${completed.map((p) => p.service).join(', ')}`);
       }
       if (inProgress.length > 0) {
-        logger.info(`  Em andamento: ${inProgress.map((p) => p.service).join(', ')}`);
+        logger.info(`  In progress: ${inProgress.map((p) => p.service).join(', ')}`);
       }
     }
   });

package/src/cli/add.command.ts

@@ -22,7 +22,7 @@ export async function addCommand(repoUrl: string, opts: AddCommandOptions): Prom
   const targetDir = resolve(rootDir, dirName);
 
   if (existsSync(targetDir)) {
-    throw new OctoError(`Diretório já existe: ${dirName}. Use --name para especificar outro nome.`);
+    throw new OctoError(`Directory already exists: ${dirName}. Use --name to specify another name.`);
   }
 
   await cloneRepository(repoUrl, targetDir);
@@ -36,10 +36,10 @@ export async function addCommand(repoUrl: string, opts: AddCommandOptions): Prom
   const added = addEntry(manifest, projectName, dirName, type);
 
   if (!added) {
-    logger.info(`Projeto "${projectName}" já está registrado no octo.yaml.`);
+    logger.info(`Project "${projectName}" is already registered in octo.yaml.`);
     return;
   }
 
   saveManifest(manifestPath, manifest, originalContent);
-  logger.info(`Projeto "${projectName}" adicionado como ${type} no octo.yaml.`);
+  logger.info(`Project "${projectName}" added as ${type} in octo.yaml.`);
 }

package/src/cli/build.command.ts

@@ -24,7 +24,7 @@ export async function buildCommand(service?: string, opts?: { affected?: boolean
   try {
     content = readFileSync(manifestPath, 'utf-8');
   } catch {
-    throw new OctoError('octo.yaml não encontrado. Execute `octo init` primeiro.');
+    throw new OctoError('octo.yaml not found. Run `octo init` first.');
   }
 
   const parsed = parseManifest(content, manifestPath);
@@ -48,11 +48,11 @@ export async function buildCommand(service?: string, opts?: { affected?: boolean
     const affected = await detector.detect(graph, rootDir);
 
     if (affected.length === 0) {
-      logger.info('Nenhum serviço afetado detectado.');
+      logger.info('No affected services detected.');
       return;
     }
 
-    logger.info(`Serviços afetados: ${affected.join(', ')}`);
+    logger.info(`Affected services: ${affected.join(', ')}`);
     result = await orchestrator.buildTargets(affected, graph, registry, buildOptions);
 
     if (result.success) {
@@ -67,7 +67,7 @@ export async function buildCommand(service?: string, opts?: { affected?: boolean
 
     if (!allNames.includes(service)) {
       throw new OctoError(
-        `Serviço "${service}" não encontrado no manifesto.\nDisponíveis: ${allNames.join(', ')}`,
+        `Service "${service}" not found in manifest.\nAvailable: ${allNames.join(', ')}`,
       );
     }
 

package/src/cli/down.command.ts

@@ -14,7 +14,7 @@ export async function downCommand(opts: { volumes?: boolean }): Promise<void> {
   try {
     content = readFileSync(manifestPath, 'utf-8');
   } catch {
-    throw new OctoError('octo.yaml não encontrado. Execute `octo init` primeiro.');
+    throw new OctoError('octo.yaml not found. Run `octo init` first.');
   }
 
   const parsed = parseManifest(content, manifestPath);

package/src/cli/graph.command.ts

@@ -5,7 +5,7 @@ import { buildGraphFromManifest } from '../graph/build-graph.js';
 import { OctoError } from '../shared/errors.js';
 
 /**
- * `octo graph` — exibe grafo de dependências no stdout em formato de lista de adjacência indentada.
+ * `octo graph` — displays the dependency graph on stdout as an indented adjacency list.
  */
 export async function graphCommand(): Promise<void> {
   const cwd = process.cwd();
@@ -15,7 +15,7 @@ export async function graphCommand(): Promise<void> {
   try {
     content = readFileSync(manifestPath, 'utf-8');
   } catch {
-    throw new OctoError(`Não foi possível ler ${manifestPath}. Execute "octo init" primeiro.`);
+    throw new OctoError(`Could not read ${manifestPath}. Run "octo init" first.`);
   }
 
   const result = parseManifest(content, manifestPath);

package/src/cli/index.ts

@@ -11,12 +11,12 @@ const program = new Command();
 program
   .name('octo')
   .description('Monorepo build orchestration, versioning, and infrastructure CLI')
-  .version('0.4.3');
+  .version('0.5.2');
 
 program
   .command('init')
-  .description('Escaneia o monorepo e gera octo.yaml')
-  .option('--standalone', 'Gera manifesto apenas para o projeto corrente')
+  .description('Scan the monorepo and generate octo.yaml')
+  .option('--standalone', 'Generate manifest for the current project only')
   .action(async (opts) => {
     const { initCommand } = await import('./init.command.js');
     await initCommand(opts);
@@ -24,7 +24,7 @@ program
 
 program
   .command('graph')
-  .description('Exibe o grafo de dependências')
+  .description('Display the dependency graph')
   .action(async () => {
     const { graphCommand } = await import('./graph.command.js');
     await graphCommand();
@@ -32,8 +32,8 @@ program
 
 program
   .command('build [service]')
-  .description('Builda serviços do monorepo')
-  .option('--affected', 'Builda apenas serviços afetados')
+  .description('Build monorepo services')
+  .option('--affected', 'Build only affected services')
   .action(async (service, opts) => {
     const { buildCommand } = await import('./build.command.js');
     await buildCommand(service, opts);
@@ -54,7 +54,7 @@ program
 
 program
   .command('up [service]')
-  .description('Sobe infraestrutura local')
+  .description('Start local infrastructure')
   .action(async (service) => {
     const { upCommand } = await import('./up.command.js');
     await upCommand(service);
@@ -62,8 +62,8 @@ program
 
 program
   .command('down')
-  .description('Para infraestrutura local')
-  .option('--volumes', 'Remove volumes também')
+  .description('Stop local infrastructure')
+  .option('--volumes', 'Remove volumes as well')
   .action(async (opts) => {
     const { downCommand } = await import('./down.command.js');
     await downCommand(opts);
@@ -71,7 +71,7 @@ program
 
 program
   .command('status')
-  .description('Exibe status dos containers')
+  .description('Show container status')
   .action(async () => {
     const { statusCommand } = await import('./status.command.js');
     await statusCommand();
@@ -79,8 +79,8 @@ program
 
 program
   .command('add <repo-url>')
-  .description('Clona um repositório e registra no octo.yaml')
-  .option('--name <name>', 'Nome customizado para o diretório clonado')
+  .description('Clone a repository and register it in octo.yaml')
+  .option('--name <name>', 'Custom name for the cloned directory')
   .action(async (repoUrl, opts) => {
     const { addCommand } = await import('./add.command.js');
     await addCommand(repoUrl, opts);

package/src/cli/init.command.ts

@@ -2,7 +2,6 @@ import { readdir, readFile, access, writeFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { logger } from '../shared/logger.js';
 import { printManifest } from '../manifest/manifest-printer.js';
-import { ensureOllamaSetup } from '../shared/ollama.js';
 import type { OctoManifest } from '../manifest/manifest-schema.js';
 
 const EXCLUDED_DIRS = new Set(['node_modules', 'dist']);
@@ -67,8 +66,6 @@ async function scanDirectory(
 }
 
 export async function initCommand(opts: { standalone?: boolean }): Promise<void> {
-  await ensureOllamaSetup();
-
   const rootDir = process.cwd();
   const results: DiscoveredProject[] = [];
 
@@ -91,7 +88,7 @@ export async function initCommand(opts: { standalone?: boolean }): Promise<void>
   }
 
   if (results.length === 0) {
-    logger.info('Nenhum pacote com package.json encontrado. Criando octo.yaml vazio.');
+    logger.info('No package.json found. Creating empty octo.yaml.');
   }
 
   const services = results.filter((p) => p.hasDockerfile).map((p) => p.name);
@@ -106,5 +103,5 @@ export async function initCommand(opts: { standalone?: boolean }): Promise<void>
   const outputPath = join(rootDir, 'octo.yaml');
   await writeFile(outputPath, yaml, 'utf-8');
 
-  logger.info(`octo.yaml gerado com ${services.length} serviço(s)${packages.length > 0 ? ` e ${packages.length} pacote(s)` : ''}.`);
+  logger.info(`octo.yaml generated with ${services.length} service(s)${packages.length > 0 ? ` and ${packages.length} package(s)` : ''}.`);
 }

package/src/cli/status.command.ts

@@ -14,7 +14,7 @@ export async function statusCommand(): Promise<void> {
   try {
     content = readFileSync(manifestPath, 'utf-8');
   } catch {
-    throw new OctoError('octo.yaml não encontrado. Execute `octo init` primeiro.');
+    throw new OctoError('octo.yaml not found. Run `octo init` first.');
   }
 
   const parsed = parseManifest(content, manifestPath);

package/src/cli/up.command.ts

@@ -14,7 +14,7 @@ export async function upCommand(service?: string): Promise<void> {
   try {
     content = readFileSync(manifestPath, 'utf-8');
   } catch {
-    throw new OctoError('octo.yaml não encontrado. Execute `octo init` primeiro.');
+    throw new OctoError('octo.yaml not found. Run `octo init` first.');
   }
 
   const parsed = parseManifest(content, manifestPath);
@@ -28,7 +28,7 @@ export async function upCommand(service?: string): Promise<void> {
     const node = graph.getNode(service);
     if (!node) {
       const available = graph.getNodeNames().join(', ');
-      throw new OctoError(`Serviço "${service}" não encontrado. Disponíveis: ${available}`);
+      throw new OctoError(`Service "${service}" not found. Available: ${available}`);
     }
     // Include service + its dependencies
     const deps = graph.getDependencies(service);

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

@@ -1,5 +1,5 @@
-import { Ollama } from 'ollama';
 import { z } from 'zod';
+import { generateJSON, isAvailable } from '../shared/llm.js';
 import { createComposeAggregator, type DiscoveredCompose, type MergedCompose } from './compose-aggregator.js';
 import { logger } from '../shared/logger.js';
 
@@ -14,7 +14,7 @@ export interface ComposeSmartMerger {
   deduplicate(composes: DiscoveredCompose[]): Promise<MergedCompose>;
 }
 
-/** Build the structured prompt for Phi-4 */
+/** Build the structured prompt */
 function buildPrompt(composes: DiscoveredCompose[]): string {
   const composesText = composes
     .map((c) => `--- ${c.serviceName} (${c.path}) ---\n${JSON.stringify(c.content, null, 2)}`)
@@ -36,18 +36,7 @@ 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 {
@@ -57,32 +46,26 @@ export function createComposeSmartMerger(): ComposeSmartMerger {
       }
 
       // Try LLM-based merge
-      if (await isOllamaAvailable(client)) {
+      if (await isAvailable()) {
         try {
-          logger.info('Usando Phi-4 para merge inteligente de compose files...');
+          logger.info('Using local AI for smart compose merge...');
           const prompt = buildPrompt(composes);
-          const response = await client.generate({
-            model: 'phi4',
-            prompt,
-            format: 'json',
-            stream: false,
-          });
+          const parsed = await generateJSON(prompt);
 
-          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;
+          if (parsed) {
+            const validated = MergedComposeSchema.safeParse(parsed);
+            if (validated.success) {
+              logger.info('Smart merge completed successfully.');
+              return validated.data;
+            }
+            logger.warn('AI output failed validation. Using deterministic fallback.');
           }
-
-          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.`);
+          logger.warn(`AI error: ${msg}. Using deterministic fallback.`);
         }
       } else {
-        logger.info('Ollama/Phi-4 indisponível. Usando merge determinístico.');
+        logger.info('Local AI unavailable. Using deterministic merge.');
       }
 
       // Fallback: deterministic merge

package/src/infra/infra-manager.ts

@@ -58,7 +58,7 @@ async function waitForHealthcheck(containerName: string): Promise<boolean> {
 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}`);
+  if (output) logger.error(`Last 20 lines of log (${containerName}):\n${output}`);
 }
 
 export function createInfraManager(servicePaths: string[]): InfraManager {
@@ -77,11 +77,11 @@ export function createInfraManager(servicePaths: string[]): InfraManager {
         return { success: true, message: 'Nenhum docker-compose.yml encontrado.' };
       }
 
-      logger.info(`Descobertos ${discovered.length} compose file(s). Merging...`);
+      logger.info(`Discovered ${discovered.length} compose file(s). Merging...`);
       const merged = await smartMerger.deduplicate(discovered);
       composePath = await writeTempCompose(merged);
 
-      logger.info('Subindo containers...');
+      logger.info('Starting 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}` };
@@ -92,7 +92,7 @@ export function createInfraManager(servicePaths: string[]): InfraManager {
       for (const svc of serviceNames) {
         const healthy = await waitForHealthcheck(svc);
         if (!healthy) {
-          logger.error(`Healthcheck timeout para container "${svc}".`);
+          logger.error(`Healthcheck timeout for container "${svc}".`);
           await showContainerLogs(svc);
           // Stop dependents but don't tear down everything
           return { success: false, message: `Healthcheck timeout: ${svc}` };

package/src/manifest/manifest-mutator.ts

@@ -19,7 +19,7 @@ export function loadOrCreateManifest(manifestPath: string): LoadedManifest {
     if (parsed.ok) {
       return { manifest: parsed.value, originalContent: content };
     }
-    throw new OctoError(`octo.yaml inválido: ${parsed.error.message}`);
+    throw new OctoError(`Invalid octo.yaml: ${parsed.error.message}`);
   }
   return { manifest: { services: [] } };
 }

package/src/shared/git.ts

@@ -15,7 +15,7 @@ export function extractRepoName(url: string): string {
   const parts = cleaned.split(/[/:]/);
   const name = parts[parts.length - 1];
   if (!name) {
-    throw new OctoError(`Não foi possível extrair o nome do repositório de: ${url}`);
+    throw new OctoError(`Could not extract repository name from: ${url}`);
   }
   return name;
 }
@@ -24,7 +24,7 @@ export function extractRepoName(url: string): string {
  * Clones a git repository into the target directory.
  */
 export async function cloneRepository(url: string, targetDir: string): Promise<void> {
-  logger.info(`Clonando ${url}...`);
+  logger.info(`Cloning ${url}...`);
 
   const result = await run('git', ['clone', url, targetDir], {
     timeout: 120_000,
@@ -32,8 +32,8 @@ export async function cloneRepository(url: string, targetDir: string): Promise<v
   });
 
   if (result.exitCode !== 0) {
-    throw new OctoError(`Falha ao clonar repositório.`);
+    throw new OctoError('Failed to clone repository.');
   }
 
-  logger.info(`Repositório clonado em ./${basename(targetDir)}`);
+  logger.info(`Repository cloned to ./${basename(targetDir)}`);
 }

package/src/shared/llm.ts

@@ -0,0 +1,83 @@
+import { pipeline, type TextGenerationPipeline } from '@huggingface/transformers';
+import { logger } from './logger.js';
+
+const MODEL_ID = 'onnx-community/Qwen2.5-0.5B-Instruct';
+
+let generator: TextGenerationPipeline | null = null;
+let initFailed = false;
+
+/**
+ * Lazily initializes the text generation pipeline.
+ * Downloads the ONNX model on first use (~500MB, cached locally).
+ */
+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;
+  }
+}
+
+/**
+ * Generates text from a prompt using the local ONNX model.
+ * Returns null if the model is unavailable or generation fails.
+ */
+export async function generate(prompt: string, maxTokens = 512): Promise<string | null> {
+  const gen = await getGenerator();
+  if (!gen) return null;
+
+  try {
+    const messages = [
+      { role: 'user', content: prompt },
+    ];
+    const result = await gen(messages, {
+      max_new_tokens: maxTokens,
+      do_sample: false,
+    });
+    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 null;
+  }
+}
+
+/**
+ * Generates structured JSON output from a prompt.
+ * Returns null if parsing fails or model is unavailable.
+ */
+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;
+
+  try {
+    return JSON.parse(jsonMatch[0]) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Checks if the LLM is available (model loaded or loadable).
+ */
+export async function isAvailable(): Promise<boolean> {
+  const gen = await getGenerator();
+  return gen !== null;
+}

package/src/shared/logger.ts

@@ -1,14 +1,12 @@
-/** Formatted output for stdout/stderr with prefixes */
-export const logger = {
-  info(message: string): void {
-    process.stdout.write(`[INFO] ${message}\n`);
-  },
-
-  error(message: string): void {
-    process.stderr.write(`[ERRO] ${message}\n`);
-  },
+import pino from 'pino';
 
-  warn(message: string): void {
-    process.stderr.write(`[AVISO] ${message}\n`);
+export const logger = pino({
+  transport: {
+    target: 'pino-pretty',
+    options: {
+      colorize: true,
+      ignore: 'pid,hostname,time',
+      messageFormat: '{msg}',
+    },
   },
-};
+});

package/src/shared/shutdown.ts

@@ -21,7 +21,7 @@ export async function triggerShutdown(signal: string): Promise<void> {
   shuttingDown = true;
 
   const { logger } = await import('./logger.js');
-  logger.warn(`Shutdown solicitado (${signal}). Cancelando operações em andamento...`);
+  logger.warn(`Shutdown requested (${signal}). Cancelling ongoing operations...`);
 
   for (const cb of callbacks) {
     try {
@@ -31,6 +31,6 @@ export async function triggerShutdown(signal: string): Promise<void> {
     }
   }
 
-  logger.info('Shutdown completo.');
+  logger.info('Shutdown complete.');
   process.exit(130);
 }

package/src/version/changelog-generator.ts

@@ -1,14 +1,12 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { Ollama } from 'ollama';
+import { generate } from '../shared/llm.js';
 import { run } from '../shared/process-runner.js';
 import { logger } from '../shared/logger.js';
 
 const HEADER = '# Changelog\n';
 
 export class ChangelogGenerator {
-  private ollama = new Ollama();
-
   async generate(packageDir: string, newVersion: string): Promise<string> {
     const changelogPath = join(packageDir, 'CHANGELOG.md');
     const commits = await this.getCommitsSinceLastTag(packageDir);
@@ -60,10 +58,6 @@ export class ChangelogGenerator {
 
   private async generateWithLLM(version: string, date: string, commits: string[]): Promise<string | null> {
     try {
-      const models = await this.ollama.list();
-      const hasModel = models.models.some((m) => m.name.startsWith('phi4'));
-      if (!hasModel) return null;
-
       const commitList = commits.map((c) => `- ${c}`).join('\n');
       const prompt = `You are a changelog writer. Given these git commits, generate a concise, well-organized changelog entry in Keep a Changelog format.
 
@@ -75,12 +69,10 @@ ${commitList}
 
 Output ONLY the markdown sections (### Added, ### Changed, etc.) with bullet points. No header, no version line.`;
 
-      const response = await this.ollama.generate({ model: 'phi4', prompt, stream: false });
-      const sections = response.response.trim();
-
+      const sections = await generate(prompt);
       if (!sections || sections.length < 10) return null;
 
-      return [`## [${version}] - ${date}`, '', sections, ''].join('\n');
+      return [`## [${version}] - ${date}`, '', sections.trim(), ''].join('\n');
     } catch {
       return null;
     }

package/src/version/version-propagator.ts

@@ -23,15 +23,15 @@ export class VersionPropagator {
     await this.propagateRecursive(packageName, newVersion, entries, visited);
 
     if (entries.length === 0) {
-      logger.info(`Nenhum projeto consome ${packageName}. Propagação encerrada.`);
+      logger.info(`No consumers found for ${packageName}. Propagation skipped.`);
       return { entries };
     }
 
     // Display summary
-    logger.info('--- Resumo da Propagação ---');
+    logger.info('--- Propagation Summary ---');
     for (const entry of entries) {
       if (entry.skipped) {
-        logger.warn(`  ${entry.project}: PULADO — ${entry.reason}`);
+        logger.warn(`  ${entry.project}: SKIPPED — ${entry.reason}`);
       } else {
         logger.info(`  ${entry.project}: ${entry.previousVersion} → ${entry.newVersion}`);
       }

package/src/shared/ollama.ts

@@ -1,96 +0,0 @@
-import { run } from './process-runner.js';
-import { logger } from './logger.js';
-import { confirm } from './prompt.js';
-
-/**
- * Checks if Ollama CLI is installed on the system.
- */
-async function isInstalled(): Promise<boolean> {
-  const result = await run('ollama', ['--version'], { timeout: 5_000 });
-  return result.exitCode === 0;
-}
-
-/**
- * Checks if the phi4 model is available locally.
- */
-async function hasModel(model: string): Promise<boolean> {
-  const result = await run('ollama', ['list'], { timeout: 10_000 });
-  if (result.exitCode !== 0) return false;
-  return result.stdout.includes(model);
-}
-
-/**
- * Ensures a system dependency is available, installing it if the user agrees.
- */
-async function ensureDependency(command: string, installCmd: string, name: string): Promise<boolean> {
-  const check = await run('which', [command], { timeout: 5_000 });
-  if (check.exitCode === 0) return true;
-
-  const shouldInstall = await confirm(`${name} não encontrado (necessário para Ollama). Instalar? (s/n) `);
-  if (!shouldInstall) return false;
-
-  const result = await run('sudo', installCmd.split(' '), { timeout: 60_000, interactive: true });
-  return result.exitCode === 0;
-}
-
-/**
- * Installs Ollama via the official install script.
- */
-async function install(): Promise<boolean> {
-  // Ollama requires zstd for extraction
-  if (!await ensureDependency('zstd', 'apt-get install -y zstd', 'zstd')) {
-    return false;
-  }
-
-  logger.info('Instalando Ollama...');
-  const result = await run('curl -fsSL https://ollama.com/install.sh | sh', [], {
-    timeout: 120_000,
-    interactive: true,
-    shell: true,
-  });
-  return result.exitCode === 0;
-}
-
-/**
- * Pulls a model from the Ollama registry.
- */
-async function pull(model: string): Promise<boolean> {
-  logger.info(`Baixando modelo ${model}...`);
-  const result = await run('ollama', ['pull', model], {
-    timeout: 300_000,
-    interactive: true,
-  });
-  return result.exitCode === 0;
-}
-
-/**
- * Ensures Ollama and the specified model are available.
- * Prompts the user interactively if installation is needed.
- */
-export async function ensureOllamaSetup(model = 'phi4'): Promise<void> {
-  if (!await isInstalled()) {
-    const shouldInstall = await confirm('Ollama não encontrado. Deseja instalar? (s/n) ');
-    if (!shouldInstall) {
-      logger.info('Ollama não instalado. Funcionalidades de IA indisponíveis.');
-      return;
-    }
-    if (!await install()) {
-      logger.info('Falha ao instalar Ollama. Prosseguindo sem IA.');
-      return;
-    }
-  }
-
-  if (!await hasModel(model)) {
-    const shouldPull = await confirm(`Modelo ${model} não encontrado. Deseja baixar? (s/n) `);
-    if (!shouldPull) {
-      logger.info(`${model} não instalado. Funcionalidades de IA indisponíveis.`);
-      return;
-    }
-    if (!await pull(model)) {
-      logger.info(`Falha ao baixar ${model}. Prosseguindo sem IA.`);
-      return;
-    }
-  }
-
-  logger.info(`Ollama + ${model} configurados.`);
-}