octo-dev 0.6.0 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octo-dev",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Build orchestration, semantic versioning, and local infrastructure management for repository workspaces",
   "type": "module",
   "license": "MIT",

package/src/cli/bump.command.ts

@@ -49,6 +49,7 @@ export async function bumpCommand(pkg: string, type: string, opts: BumpCommandOp
     );
   }
 
+  await ensureRepositories(manifest, rootDir);
   const graph = buildGraphFromManifest(manifest, rootDir);
   const node = graph.getNode(pkg);
 

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.6.0');
+  .version('0.7.1');
 
 program
   .command('init')
@@ -86,6 +86,14 @@ program
     await addCommand(repoUrl, opts);
   });
 
+program
+  .command('sync')
+  .description('Clone all missing repositories declared in octo.yaml')
+  .action(async () => {
+    const { syncCommand } = await import('./sync.command.js');
+    await syncCommand();
+  });
+
 const config = program
   .command('config')
   .description('Configure octo and git settings');

package/src/cli/init.command.ts

@@ -2,6 +2,7 @@ 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 { ensureRepositories } from '../shared/sync.js';
 import type { OctoManifest } from '../manifest/manifest-schema.js';
 
 const EXCLUDED_DIRS = new Set(['node_modules', 'dist']);
@@ -104,4 +105,7 @@ export async function initCommand(opts: { standalone?: boolean }): Promise<void>
   await writeFile(outputPath, yaml, 'utf-8');
 
   logger.info(`octo.yaml generated with ${services.length} service(s)${packages.length > 0 ? ` and ${packages.length} package(s)` : ''}.`);
+
+  // Sync: clone any missing remote repos declared in the manifest
+  await ensureRepositories(manifest, rootDir);
 }

package/src/cli/sync.command.ts

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseManifest } from '../manifest/manifest-parser.js';
+import { ensureRepositories } from '../shared/sync.js';
+import { OctoError } from '../shared/errors.js';
+
+/**
+ * octo sync
+ *
+ * Clones all missing repositories declared in octo.yaml.
+ * Repos using org/repo format are cloned from GitHub into ./repo-name.
+ */
+export async function syncCommand(): Promise<void> {
+  const rootDir = process.cwd();
+  const manifestPath = resolve(rootDir, 'octo.yaml');
+
+  let content: string;
+  try {
+    content = readFileSync(manifestPath, 'utf-8');
+  } catch {
+    throw new OctoError('octo.yaml not found. Run `octo init` first.');
+  }
+
+  const parsed = parseManifest(content, manifestPath);
+  if (!parsed.ok) throw parsed.error;
+
+  await ensureRepositories(parsed.value, rootDir);
+}

package/src/graph/build-graph.ts

@@ -1,6 +1,7 @@
 import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { DependencyGraph, type GraphNode } from './dependency-graph.js';
+import { isRemoteRepo, extractRepoName } from '../shared/git.js';
 import type { OctoManifest, ServiceEntry, PackageEntry } from '../manifest/manifest-schema.js';
 
 interface PackageJson {
@@ -94,11 +95,14 @@ export function buildGraphFromManifest(manifest: OctoManifest, rootDir: string):
 
     if (entry.path) {
       dir = resolve(rootDir, entry.path);
+    } else if (isRemoteRepo(entry.name)) {
+      // org/repo format — directory is the repo name
+      dir = resolve(rootDir, extractRepoName(entry.name));
     } else {
       dir = findPackageDir(rootDir, entry.name);
     }
 
-    if (!dir) continue;
+    if (!dir || !existsSync(dir)) continue;
 
     resolvedPaths.set(entry.name, dir);
     const node: GraphNode = { name: entry.name, type: entry.type, path: dir };

package/src/shared/git-auth.ts

@@ -0,0 +1,37 @@
+import { ask } 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.
+ *
+ * @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): ');
+  cachedToken = input || undefined;
+  return cachedToken;
+}
+
+/**
+ * Embeds a token into an HTTPS git URL for credential-less cloning.
+ * Produces format: https://<token>@github.com/org/repo.git
+ *
+ * @param baseUrl - The base HTTPS clone URL (e.g. "https://github.com/org/repo.git").
+ * @param token - The GitHub PAT to embed.
+ * @returns The URL with credentials embedded in the authority segment.
+ */
+export function embedTokenInUrl(baseUrl: string, token: string): string {
+  return baseUrl.replace('https://', `https://${token}@`);
+}
+
+/**
+ * Clears the cached token from process memory.
+ * Should be called after sync completes as defense-in-depth.
+ */
+export function clearCachedToken(): void {
+  cachedToken = undefined;
+}

package/src/shared/git.ts

@@ -4,11 +4,15 @@ import { logger } from './logger.js';
 import { OctoError } from './errors.js';
 
 /**
- * Extracts the repository name from a git URL.
- * Supports HTTPS and SSH formats:
+ * Extracts the repository name from a git URL or org/repo shorthand.
+ * Supports HTTPS, SSH, and GitHub shorthand formats:
  *   https://github.com/user/repo.git → repo
  *   git@github.com:user/repo.git    → repo
- *   https://github.com/user/repo    → repo
+ *   user/repo                        → repo
+ *
+ * @param url - Git URL or org/repo shorthand.
+ * @returns The repository name (last segment without .git suffix).
+ * @throws OctoError if the name cannot be extracted.
  */
 export function extractRepoName(url: string): string {
   const cleaned = url.replace(/\.git$/, '').replace(/\/$/, '');
@@ -20,19 +24,43 @@ export function extractRepoName(url: string): string {
   return name;
 }
 
+/**
+ * Checks if a manifest entry name is a git remote reference (org/repo format).
+ *
+ * @param name - The entry name from octo.yaml.
+ * @returns true if the name matches org/repo pattern (contains exactly one slash, no @ prefix).
+ */
+export function isRemoteRepo(name: string): boolean {
+  return /^[^@/]+\/[^/]+$/.test(name);
+}
+
+/**
+ * Converts an org/repo shorthand to a full GitHub HTTPS URL.
+ *
+ * @param shorthand - The org/repo string (e.g. "vguerato/spectre-tasks").
+ * @returns Full clone URL (e.g. "https://github.com/vguerato/spectre-tasks.git").
+ */
+export function resolveGitUrl(shorthand: string): string {
+  return `https://github.com/${shorthand}.git`;
+}
+
 /**
  * Clones a git repository into the target directory.
+ * Uses interactive stdio when no auth is embedded in the URL.
+ *
+ * @param url - Full git URL to clone (may contain embedded token).
+ * @param targetDir - Absolute path where the repo will be cloned.
+ * @throws OctoError if clone exits with non-zero code.
  */
 export async function cloneRepository(url: string, targetDir: string): Promise<void> {
-  logger.info(`Cloning ${url}...`);
+  // Log without exposing token
+  const safeUrl = url.replace(/\/\/[^@]+@/, '//***@');
+  logger.info(`Cloning ${safeUrl}...`);
 
-  const result = await run('git', ['clone', url, targetDir], {
-    timeout: 120_000,
-    interactive: true,
-  });
+  const result = await run('git', ['clone', url, targetDir], { timeout: 120_000 });
 
   if (result.exitCode !== 0) {
-    throw new OctoError('Failed to clone repository.');
+    throw new OctoError(`Failed to clone repository: ${result.stderr.trim() || 'unknown error'}`);
   }
 
   logger.info(`Repository cloned to ./${basename(targetDir)}`);

package/src/shared/logger.ts

@@ -5,7 +5,7 @@ export const logger = pino({
     target: 'pino-pretty',
     options: {
       colorize: true,
-      ignore: 'pid,hostname,time',
+      ignore: 'pid,hostname,time,level',
       messageFormat: '{msg}',
     },
   },

package/src/shared/prompt.ts

@@ -1,8 +1,27 @@
 import { createInterface } from 'node:readline';
 
+/**
+ * Prompts the user with a question and returns their text input.
+ *
+ * @param message - The prompt message displayed to the user.
+ * @returns The trimmed user input string.
+ */
+export function ask(message: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
 /**
  * Prompts the user with a yes/no question via stdin.
- * Accepts 'y', 'Y', 's', 'S' as affirmative.
+ * Accepts 'y', 'Y', 's', 'S' as affirmative responses.
+ *
+ * @param message - The yes/no question to display.
+ * @returns `true` if the user confirmed, `false` otherwise.
  */
 export function confirm(message: string): Promise<boolean> {
   const rl = createInterface({ input: process.stdin, output: process.stdout });

package/src/shared/sync.ts

@@ -0,0 +1,82 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { logger } from './logger.js';
+import { isRemoteRepo, resolveGitUrl, extractRepoName, cloneRepository } from './git.js';
+import { acquireGitToken, embedTokenInUrl, clearCachedToken } from './git-auth.js';
+import type { OctoManifest, ServiceEntry, PackageEntry } from '../manifest/manifest-schema.js';
+
+/**
+ * Ensures all repositories declared in the manifest are present locally.
+ * Prompts for a GitHub token once, embeds it in clone URLs (in-memory only).
+ * Token is cleared from memory after all clones complete.
+ *
+ * @param manifest - The parsed octo.yaml manifest.
+ * @param rootDir - Workspace root directory where repos are cloned.
+ * @returns Number of repositories that were cloned.
+ */
+export async function ensureRepositories(manifest: OctoManifest, rootDir: string): Promise<number> {
+  const entries = collectEntries(manifest);
+  const pending = entries.filter(({ name, path: explicitPath }) => {
+    if (!isRemoteRepo(name)) return false;
+    const repoName = extractRepoName(name);
+    const targetDir = resolve(rootDir, explicitPath ?? repoName);
+    return !existsSync(targetDir);
+  });
+
+  if (pending.length === 0) return 0;
+
+  logger.info(`${pending.length} repository(ies) to clone.`);
+
+  // Acquire token once for all clones
+  const token = await acquireGitToken();
+
+  try {
+    let cloned = 0;
+    for (const { name, path: explicitPath } of pending) {
+      const repoName = extractRepoName(name);
+      const targetDir = resolve(rootDir, explicitPath ?? repoName);
+      const baseUrl = resolveGitUrl(name);
+      const url = token ? embedTokenInUrl(baseUrl, token) : baseUrl;
+      await cloneRepository(url, targetDir);
+      cloned++;
+    }
+
+    logger.info(`Synced ${cloned} repository(ies).`);
+    return cloned;
+  } finally {
+    clearCachedToken();
+  }
+}
+
+/**
+ * Extracts all entry names and optional path overrides from the manifest.
+ *
+ * @param manifest - The parsed octo.yaml manifest.
+ * @returns Array of entries with name and optional explicit path.
+ */
+function collectEntries(manifest: OctoManifest): Array<{ name: string; path?: string }> {
+  const results: Array<{ name: string; path?: string }> = [];
+
+  for (const entry of manifest.services) {
+    results.push(resolveEntry(entry));
+  }
+  for (const entry of manifest.packages ?? []) {
+    results.push(resolveEntry(entry));
+  }
+
+  return results;
+}
+
+/**
+ * Resolves the name and optional path from a manifest entry.
+ * String entries return name only. Object entries extract key + path config.
+ *
+ * @param entry - A service or package entry from octo.yaml.
+ * @returns Object with resolved name and optional path override.
+ */
+function resolveEntry(entry: ServiceEntry | PackageEntry): { name: string; path?: string } {
+  if (typeof entry === 'string') return { name: entry };
+  const key = Object.keys(entry)[0];
+  const config = (entry as Record<string, { path?: string }>)[key];
+  return { name: key, path: config?.path };
+}