octo-dev 0.3.1 → 0.4.0

package/bin/octo.js

@@ -1,13 +1,20 @@
 #!/usr/bin/env node
 import { execFileSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { resolve, dirname } from 'node:path';
+import { createRequire } from 'node:module';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// Resolve tsx ESM loader relative to this package's node_modules
+const tsxEsmPath = require.resolve('tsx/esm');
+const tsxImportUrl = pathToFileURL(tsxEsmPath).href;
+
 const entry = resolve(__dirname, '..', 'src', 'cli', 'index.ts');
 
 try {
-  execFileSync('node', ['--import', 'tsx', entry, ...process.argv.slice(2)], {
+  execFileSync('node', ['--import', tsxImportUrl, entry, ...process.argv.slice(2)], {
     stdio: 'inherit',
     env: process.env,
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octo-dev",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "CLI for monorepo build orchestration, semantic versioning, and local infrastructure management",
   "type": "module",
   "license": "MIT",

package/src/cli/build.command.ts

@@ -62,7 +62,7 @@ export async function buildCommand(service?: string, opts?: { affected?: boolean
     // Validate service name against manifest
     const allNames = [
       ...manifest.services.map(entryName),
-      ...manifest.packages.map(entryName),
+      ...(manifest.packages ?? []).map(entryName),
     ];
 
     if (!allNames.includes(service)) {

package/src/cli/bump.command.ts

@@ -40,7 +40,7 @@ export async function bumpCommand(pkg: string, type: string, opts: BumpCommandOp
 
   const allNames = [
     ...manifest.services.map(entryName),
-    ...manifest.packages.map(entryName),
+    ...(manifest.packages ?? []).map(entryName),
   ];
 
   if (!allNames.includes(pkg)) {

package/src/cli/index.ts

@@ -11,7 +11,7 @@ const program = new Command();
 program
   .name('octo')
   .description('Monorepo build orchestration, versioning, and infrastructure CLI')
-  .version('0.1.0');
+  .version('0.4.0');
 
 program
   .command('init')

package/src/cli/init.command.ts

@@ -1,8 +1,8 @@
 import { readdir, readFile, access, writeFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { logger } from '../shared/logger.js';
-import { OctoError } from '../shared/errors.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,11 +67,12 @@ async function scanDirectory(
 }
 
 export async function initCommand(opts: { standalone?: boolean }): Promise<void> {
+  await ensureOllamaSetup();
+
   const rootDir = process.cwd();
   const results: DiscoveredProject[] = [];
 
   if (opts.standalone) {
-    // Only scan current directory, no recursion into subdirectories
     const pkgPath = join(rootDir, 'package.json');
     if (await exists(pkgPath)) {
       try {
@@ -90,17 +91,20 @@ export async function initCommand(opts: { standalone?: boolean }): Promise<void>
   }
 
   if (results.length === 0) {
-    throw new OctoError('Nenhum pacote com package.json válido encontrado.', 1);
+    logger.info('Nenhum pacote com package.json encontrado. Criando octo.yaml vazio.');
   }
 
   const services = results.filter((p) => p.hasDockerfile).map((p) => p.name);
   const packages = results.filter((p) => !p.hasDockerfile).map((p) => p.name);
 
-  const manifest: OctoManifest = { services, packages };
-  const yaml = printManifest(manifest);
+  const manifest: OctoManifest = { services };
+  if (packages.length > 0) {
+    manifest.packages = packages;
+  }
 
+  const yaml = printManifest(manifest);
   const outputPath = join(rootDir, 'octo.yaml');
   await writeFile(outputPath, yaml, 'utf-8');
 
-  logger.info(`octo.yaml gerado com ${services.length} serviço(s) e ${packages.length} pacote(s).`);
+  logger.info(`octo.yaml gerado com ${services.length} serviço(s)${packages.length > 0 ? ` e ${packages.length} pacote(s)` : ''}.`);
 }

package/src/graph/build-graph.ts

@@ -83,7 +83,7 @@ export function buildGraphFromManifest(manifest: OctoManifest, rootDir: string):
     const resolved = resolveEntry(entry);
     allEntries.push({ ...resolved, type: 'service' });
   }
-  for (const entry of manifest.packages) {
+  for (const entry of manifest.packages ?? []) {
     const resolved = resolveEntry(entry);
     allEntries.push({ ...resolved, type: 'package' });
   }

package/src/manifest/manifest-mutator.ts

@@ -21,7 +21,7 @@ export function loadOrCreateManifest(manifestPath: string): LoadedManifest {
     }
     throw new OctoError(`octo.yaml inválido: ${parsed.error.message}`);
   }
-  return { manifest: { services: [], packages: [] } };
+  return { manifest: { services: [] } };
 }
 
 /**
@@ -37,7 +37,11 @@ export function addEntry(
   dirName: string,
   type: 'service' | 'package',
 ): boolean {
-  const list = type === 'service' ? manifest.services : manifest.packages;
+  if (type === 'package' && !manifest.packages) {
+    manifest.packages = [];
+  }
+
+  const list = type === 'service' ? manifest.services : manifest.packages!;
 
   const alreadyExists = list.some((entry) => {
     if (typeof entry === 'string') return entry === name;

package/src/manifest/manifest-printer.ts

@@ -63,10 +63,15 @@ export function printManifest(manifest: OctoManifest, originalContent?: string):
 
   // Only update services/packages if values actually changed
   for (const key of ['services', 'packages'] as const) {
+    const value = manifest[key];
+    if (value === undefined) {
+      if (doc.has(key)) doc.delete(key);
+      continue;
+    }
     const existingNode = doc.get(key, true);
     const existingPlain = nodeToPlain(existingNode);
-    if (!deepEqual(existingPlain, manifest[key])) {
-      doc.set(key, manifest[key]);
+    if (!deepEqual(existingPlain, value)) {
+      doc.set(key, value);
     }
     // If equal, leave the AST node untouched (preserves all comments)
   }

package/src/manifest/manifest-schema.ts

@@ -25,7 +25,7 @@ export const OctoManifestSchema = z.object({
     'pre-bump': z.array(HookDefinitionSchema).optional(),
   }).optional(),
   services: z.array(ServiceEntrySchema),
-  packages: z.array(PackageEntrySchema),
+  packages: z.array(PackageEntrySchema).optional(),
 });
 
 export type OctoManifest = z.infer<typeof OctoManifestSchema>;

package/src/shared/ollama.ts

@@ -0,0 +1,76 @@
+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);
+}
+
+/**
+ * Installs Ollama via the official install script.
+ */
+async function install(): Promise<boolean> {
+  logger.info('Instalando Ollama...');
+  const result = await run('curl', ['-fsSL', 'https://ollama.com/install.sh', '|', 'sh'], {
+    timeout: 120_000,
+    interactive: 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.`);
+}

package/src/shared/prompt.ts

@@ -0,0 +1,16 @@
+import { createInterface } from 'node:readline';
+
+/**
+ * Prompts the user with a yes/no question via stdin.
+ * Accepts 'y', 'Y', 's', 'S' as affirmative.
+ */
+export function confirm(message: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve(normalized === 'y' || normalized === 's');
+    });
+  });
+}

package/src/version/version-bumper.ts

@@ -1,10 +1,10 @@
-import { createInterface } from 'node:readline';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import semver from 'semver';
 import { run } from '../shared/process-runner.js';
 import { logger } from '../shared/logger.js';
 import { OctoError } from '../shared/errors.js';
+import { confirm } from '../shared/prompt.js';
 
 export type BumpType = 'patch' | 'minor' | 'major';
 
@@ -29,16 +29,6 @@ export interface PropagationEntry {
   reason?: string;
 }
 
-function confirm(message: string): Promise<boolean> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(message, (answer) => {
-      rl.close();
-      resolve(answer.trim().toLowerCase() === 'y');
-    });
-  });
-}
-
 export class VersionBumper {
   async bump(packageDir: string, packageName: string, type: BumpType = 'patch', options: BumpOptions = {}): Promise<BumpResult> {
     const pkgJsonPath = join(packageDir, 'package.json');