octo-dev 0.2.2 → 0.3.0

package/package.json

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

package/src/cli/add.command.ts

@@ -0,0 +1,45 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { logger } from '../shared/logger.js';
+import { OctoError } from '../shared/errors.js';
+import { extractRepoName, cloneRepository } from '../shared/git.js';
+import { detectProjectType, resolveProjectName } from '../manifest/manifest-discovery.js';
+import { loadOrCreateManifest, addEntry, saveManifest } from '../manifest/manifest-mutator.js';
+
+export interface AddCommandOptions {
+  name?: string;
+}
+
+/**
+ * octo add <repo-url>
+ *
+ * Clones a repository and registers it in octo.yaml.
+ * The directory is resolved automatically from the repo name (or --name override).
+ */
+export async function addCommand(repoUrl: string, opts: AddCommandOptions): Promise<void> {
+  const rootDir = process.cwd();
+  const dirName = opts.name || extractRepoName(repoUrl);
+  const targetDir = resolve(rootDir, dirName);
+
+  if (existsSync(targetDir)) {
+    throw new OctoError(`Diretório já existe: ${dirName}. Use --name para especificar outro nome.`);
+  }
+
+  await cloneRepository(repoUrl, targetDir);
+
+  const type = detectProjectType(targetDir);
+  const projectName = resolveProjectName(targetDir, dirName);
+
+  const manifestPath = resolve(rootDir, 'octo.yaml');
+  const { manifest, originalContent } = loadOrCreateManifest(manifestPath);
+
+  const added = addEntry(manifest, projectName, dirName, type);
+
+  if (!added) {
+    logger.info(`Projeto "${projectName}" já está registrado no octo.yaml.`);
+    return;
+  }
+
+  saveManifest(manifestPath, manifest, originalContent);
+  logger.info(`Projeto "${projectName}" adicionado como ${type} no octo.yaml.`);
+}

package/src/cli/index.ts

@@ -77,4 +77,13 @@ program
     await statusCommand();
   });
 
+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')
+  .action(async (repoUrl, opts) => {
+    const { addCommand } = await import('./add.command.js');
+    await addCommand(repoUrl, opts);
+  });
+
 program.parse();

package/src/manifest/manifest-discovery.ts

@@ -1,4 +1,4 @@
-import { readdirSync, statSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { ManifestError } from '../shared/errors.js';
 import { logger } from '../shared/logger.js';
@@ -142,3 +142,29 @@ export function displayDiscoveredProjects(rootDir: string): DiscoveredManifest[]
   detectNameCollisions(manifests);
   return manifests;
 }
+
+/**
+ * Detects whether a project directory is a service (has Dockerfile) or a package.
+ */
+export function detectProjectType(projectDir: string): 'service' | 'package' {
+  return existsSync(join(projectDir, 'Dockerfile')) ? 'service' : 'package';
+}
+
+/**
+ * Resolves the project name from package.json, falling back to the directory name.
+ */
+export function resolveProjectName(projectDir: string, fallbackName: string): string {
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const content = readFileSync(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content);
+      if (pkg.name && typeof pkg.name === 'string') {
+        return pkg.name;
+      }
+    } catch {
+      // Fall through to fallback
+    }
+  }
+  return fallbackName;
+}

package/src/manifest/manifest-mutator.ts

@@ -0,0 +1,70 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { parseManifest } from './manifest-parser.js';
+import { printManifest } from './manifest-printer.js';
+import { OctoError } from '../shared/errors.js';
+import type { OctoManifest } from './manifest-schema.js';
+
+export interface LoadedManifest {
+  manifest: OctoManifest;
+  originalContent?: string;
+}
+
+/**
+ * Loads an existing octo.yaml manifest, or returns a minimal empty one.
+ */
+export function loadOrCreateManifest(manifestPath: string): LoadedManifest {
+  if (existsSync(manifestPath)) {
+    const content = readFileSync(manifestPath, 'utf-8');
+    const parsed = parseManifest(content, manifestPath);
+    if (parsed.ok) {
+      return { manifest: parsed.value, originalContent: content };
+    }
+    throw new OctoError(`octo.yaml inválido: ${parsed.error.message}`);
+  }
+  return { manifest: { services: [], packages: [] } };
+}
+
+/**
+ * Adds a project entry to the manifest, avoiding duplicates.
+ * If the directory name matches the project name, registers as a simple string
+ * (octo resolves the path by convention). Otherwise, uses an object with explicit path.
+ *
+ * Returns true if the entry was added, false if it already existed.
+ */
+export function addEntry(
+  manifest: OctoManifest,
+  name: string,
+  dirName: string,
+  type: 'service' | 'package',
+): boolean {
+  const list = type === 'service' ? manifest.services : manifest.packages;
+
+  const alreadyExists = list.some((entry) => {
+    if (typeof entry === 'string') return entry === name;
+    if (typeof entry === 'object' && entry !== null) return Object.keys(entry).includes(name);
+    return false;
+  });
+
+  if (alreadyExists) {
+    return false;
+  }
+
+  if (name === dirName) {
+    list.push(name);
+  } else {
+    list.push({ [name]: { path: `./${dirName}` } });
+  }
+  return true;
+}
+
+/**
+ * Persists the manifest to disk, preserving comments when possible.
+ */
+export function saveManifest(
+  manifestPath: string,
+  manifest: OctoManifest,
+  originalContent?: string,
+): void {
+  const yaml = printManifest(manifest, originalContent);
+  writeFileSync(manifestPath, yaml, 'utf-8');
+}

package/src/shared/git.ts

@@ -0,0 +1,39 @@
+import { basename } from 'node:path';
+import { run } from './process-runner.js';
+import { logger } from './logger.js';
+import { OctoError } from './errors.js';
+
+/**
+ * Extracts the repository name from a git URL.
+ * Supports HTTPS and SSH formats:
+ *   https://github.com/user/repo.git → repo
+ *   git@github.com:user/repo.git    → repo
+ *   https://github.com/user/repo    → repo
+ */
+export function extractRepoName(url: string): string {
+  const cleaned = url.replace(/\.git$/, '').replace(/\/$/, '');
+  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}`);
+  }
+  return name;
+}
+
+/**
+ * Clones a git repository into the target directory.
+ */
+export async function cloneRepository(url: string, targetDir: string): Promise<void> {
+  logger.info(`Clonando ${url}...`);
+
+  const result = await run('git', ['clone', url, targetDir], {
+    timeout: 120_000,
+    interactive: true,
+  });
+
+  if (result.exitCode !== 0) {
+    throw new OctoError(`Falha ao clonar repositório.`);
+  }
+
+  logger.info(`Repositório clonado em ./${basename(targetDir)}`);
+}

package/src/shared/process-runner.ts

@@ -4,6 +4,8 @@ export interface RunOptions {
   cwd?: string;
   timeout?: number;
   env?: Record<string, string>;
+  /** When true, inherits stdio so the user can interact (e.g. git password prompts) */
+  interactive?: boolean;
 }
 
 export interface RunResult {
@@ -14,20 +16,23 @@ export interface RunResult {
 
 /** Wrapper for child_process.spawn with Promise, timeout, and stdout/stderr capture */
 export function run(command: string, args: string[] = [], options: RunOptions = {}): Promise<RunResult> {
-  const { cwd, timeout = 60_000, env } = options;
+  const { cwd, timeout = 60_000, env, interactive = false } = options;
 
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd,
       env: env ? { ...process.env, ...env } : process.env,
       shell: true,
+      stdio: interactive ? 'inherit' : 'pipe',
     });
 
     let stdout = '';
     let stderr = '';
 
-    child.stdout.on('data', (data: Buffer) => { stdout += data.toString(); });
-    child.stderr.on('data', (data: Buffer) => { stderr += data.toString(); });
+    if (!interactive) {
+      child.stdout!.on('data', (data: Buffer) => { stdout += data.toString(); });
+      child.stderr!.on('data', (data: Buffer) => { stderr += data.toString(); });
+    }
 
     const timer = setTimeout(() => {
       child.kill('SIGTERM');