all-hands-cli 0.1.0

package/src/commands/sync.ts

@@ -0,0 +1,289 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { basename, dirname, join, resolve } from 'path';
+import { isGitRepo, getStagedFiles } from '../lib/git.js';
+import { Manifest, filesAreDifferent } from '../lib/manifest.js';
+import { getAllhandsRoot } from '../lib/paths.js';
+import { ConflictResolution, askConflictResolution, confirm, getNextBackupPath } from '../lib/ui.js';
+import { SYNC_CONFIG_FILENAME, SYNC_CONFIG_TEMPLATE } from '../lib/constants.js';
+import { restoreDotfiles } from '../lib/dotfiles.js';
+import { ensureTargetLines } from '../lib/target-lines.js';
+
+const AH_SHIM_SCRIPT = `#!/bin/bash
+# AllHands CLI shim - finds and executes project-local .allhands/harness/ah
+# Installed by: npx all-hands sync
+
+dir="$PWD"
+while [ "$dir" != "/" ]; do
+  if [ -x "$dir/.allhands/harness/ah" ]; then
+    exec "$dir/.allhands/harness/ah" "$@"
+  fi
+  dir="$(dirname "$dir")"
+done
+
+echo "error: not in an all-hands project (no .allhands/harness/ah found)" >&2
+echo "hint: run 'npx all-hands sync .' to initialize this project" >&2
+exit 1
+`;
+
+function setupAhShim(): { installed: boolean; path: string | null; inPath: boolean } {
+  const localBin = join(homedir(), '.local', 'bin');
+  const shimPath = join(localBin, 'ah');
+
+  // Check if ~/.local/bin is in PATH
+  const pathEnv = process.env.PATH || '';
+  const inPath = pathEnv.split(':').some(p =>
+    p === localBin || p === join(homedir(), '.local/bin')
+  );
+
+  // Check if shim already exists and is current
+  if (existsSync(shimPath)) {
+    const existing = readFileSync(shimPath, 'utf-8');
+    if (existing.includes('.allhands/harness/ah')) {
+      return { installed: false, path: shimPath, inPath };
+    }
+  }
+
+  // Create ~/.local/bin if needed
+  mkdirSync(localBin, { recursive: true });
+
+  // Write the shim
+  writeFileSync(shimPath, AH_SHIM_SCRIPT, { mode: 0o755 });
+
+  return { installed: true, path: shimPath, inPath };
+}
+
+export async function cmdSync(target: string = '.', autoYes: boolean = false, init: boolean = false): Promise<number> {
+  const resolvedTarget = resolve(process.cwd(), target);
+  const allhandsRoot = getAllhandsRoot();
+
+  // Detect if this is a first-time init or an update
+  const targetAllhandsDir = join(resolvedTarget, '.allhands');
+  const isFirstTime = !existsSync(targetAllhandsDir);
+
+  if (isFirstTime) {
+    console.log(`Initializing allhands in: ${resolvedTarget}`);
+  } else {
+    console.log(`Updating allhands in: ${resolvedTarget}`);
+  }
+  console.log(`Source: ${allhandsRoot}`);
+
+  if (!existsSync(resolvedTarget)) {
+    console.error(`Error: Target directory does not exist: ${resolvedTarget}`);
+    return 1;
+  }
+
+  if (!isGitRepo(resolvedTarget)) {
+    console.error(`Warning: Target is not a git repository: ${resolvedTarget}`);
+    if (!autoYes) {
+      if (!(await confirm('Continue anyway?'))) {
+        console.log('Aborted.');
+        return 1;
+      }
+    }
+  }
+
+  // Update-only: Check for staged changes to managed files
+  if (!isFirstTime) {
+    const manifest = new Manifest(allhandsRoot);
+    const distributable = manifest.getDistributableFiles();
+    const staged = getStagedFiles(resolvedTarget);
+    const managedPaths = new Set(distributable);
+
+    const stagedConflicts = [...staged].filter(f => managedPaths.has(f));
+    if (stagedConflicts.length > 0) {
+      console.error('Error: Staged changes detected in managed files:');
+      for (const f of stagedConflicts.sort()) {
+        console.error(`  - ${f}`);
+      }
+      console.error("\nRun 'git stash' or commit first.");
+      return 1;
+    }
+  }
+
+  // Load manifest for file-by-file sync
+  const manifest = new Manifest(allhandsRoot);
+  const distributable = manifest.getDistributableFiles();
+
+  // Filter out init-only files when --init is not set
+  if (!init) {
+    for (const relPath of [...distributable]) {
+      if (manifest.isInitOnly(relPath)) {
+        distributable.delete(relPath);
+      }
+    }
+  }
+
+  let copied = 0;
+  let created = 0;
+  let skipped = 0;
+  let resolution: ConflictResolution = 'overwrite';
+  const conflicts: string[] = [];
+  const deletedInSource: string[] = [];
+
+  // Detect conflicts and deleted files
+  for (const relPath of distributable) {
+    const sourceFile = join(allhandsRoot, relPath);
+    const targetFile = join(resolvedTarget, relPath);
+
+    if (!existsSync(sourceFile)) {
+      // Update-only: track deleted files
+      if (!isFirstTime && existsSync(targetFile)) {
+        deletedInSource.push(relPath);
+      }
+      continue;
+    }
+
+    if (existsSync(targetFile)) {
+      if (filesAreDifferent(sourceFile, targetFile)) {
+        conflicts.push(relPath);
+      }
+    }
+  }
+
+  // Handle conflicts
+  if (conflicts.length > 0) {
+    if (autoYes) {
+      resolution = 'overwrite';
+      console.log(`\nAuto-overwriting ${conflicts.length} conflicting files (--yes mode)`);
+    } else {
+      resolution = await askConflictResolution(conflicts);
+      if (resolution === 'cancel') {
+        console.log('Aborted. No changes made.');
+        return 1;
+      }
+    }
+
+    if (resolution === 'backup') {
+      console.log('\nCreating backups...');
+      for (const relPath of conflicts) {
+        const targetFile = join(resolvedTarget, relPath);
+        const bkPath = getNextBackupPath(targetFile);
+        copyFileSync(targetFile, bkPath);
+        console.log(`  ${relPath} → ${basename(bkPath)}`);
+      }
+    }
+  }
+
+  // Copy files
+  console.log('\nCopying allhands files...');
+  console.log(`Found ${distributable.size} files to distribute`);
+
+  for (const relPath of [...distributable].sort()) {
+    const sourceFile = join(allhandsRoot, relPath);
+    const targetFile = join(resolvedTarget, relPath);
+
+    if (!existsSync(sourceFile)) continue;
+
+    mkdirSync(dirname(targetFile), { recursive: true });
+
+    if (existsSync(targetFile)) {
+      if (!filesAreDifferent(sourceFile, targetFile)) {
+        skipped++;
+        continue;
+      }
+      copyFileSync(sourceFile, targetFile);
+      copied++;
+    } else {
+      copyFileSync(sourceFile, targetFile);
+      created++;
+    }
+  }
+
+  // Restore dotfiles (gitignore → .gitignore, etc.)
+  restoreDotfiles(resolvedTarget);
+
+  // Update-only: Handle deleted files
+  if (!isFirstTime && deletedInSource.length > 0) {
+    console.log(`\n${deletedInSource.length} files removed from allhands source:`);
+    for (const f of deletedInSource) {
+      console.log(`  - ${f}`);
+    }
+    const shouldDelete = autoYes || (await confirm('Delete these from target?'));
+    if (shouldDelete) {
+      for (const f of deletedInSource) {
+        const targetFile = join(resolvedTarget, f);
+        if (existsSync(targetFile)) {
+          unlinkSync(targetFile);
+          console.log(`  Deleted: ${f}`);
+        }
+      }
+    }
+  }
+
+  // Ensure target files have required lines (CLAUDE.md, .gitignore, .tldrignore)
+  console.log('\nSyncing target-lines...');
+  const targetLinesUpdated = ensureTargetLines(resolvedTarget, true);
+
+  // Copy .env.ai.example
+  const envExamples = ['.env.example', '.env.ai.example'];
+  for (const envExample of envExamples) {
+    const sourceEnv = join(allhandsRoot, envExample);
+    const targetEnv = join(resolvedTarget, envExample);
+
+    if (existsSync(sourceEnv)) {
+      console.log(`Copying ${envExample}`);
+      copyFileSync(sourceEnv, targetEnv);
+    }
+  }
+
+  // Init-only: Setup ah CLI shim in ~/.local/bin
+  let shimResult: { installed: boolean; path: string | null; inPath: boolean } | null = null;
+  if (isFirstTime) {
+    console.log('\nSetting up `ah` command...');
+    shimResult = setupAhShim();
+    if (shimResult.installed) {
+      console.log(`  Installed shim to ${shimResult.path}`);
+    } else {
+      console.log(`  Shim already installed at ${shimResult.path}`);
+    }
+    if (!shimResult.inPath) {
+      console.log('  Warning: ~/.local/bin is not in your PATH');
+      console.log('  Add this to your shell config (.zshrc/.bashrc):');
+      console.log('    export PATH="$HOME/.local/bin:$PATH"');
+    }
+  }
+
+  // Init-only: Offer to create sync config for push command
+  let syncConfigCreated = false;
+  if (isFirstTime) {
+    const syncConfigPath = join(resolvedTarget, SYNC_CONFIG_FILENAME);
+
+    if (existsSync(syncConfigPath)) {
+      console.log(`\n${SYNC_CONFIG_FILENAME} already exists - skipping`);
+    } else if (!autoYes) {
+      console.log('\nThe push command lets you contribute changes back to all-hands.');
+      console.log('A sync config file lets you customize which files to include/exclude.');
+      if (await confirm(`Create ${SYNC_CONFIG_FILENAME}?`)) {
+        writeFileSync(syncConfigPath, JSON.stringify(SYNC_CONFIG_TEMPLATE, null, 2) + '\n');
+        syncConfigCreated = true;
+        console.log(`  Created ${SYNC_CONFIG_FILENAME}`);
+      }
+    }
+  }
+
+  // Summary
+  console.log(`\n${'='.repeat(60)}`);
+  if (isFirstTime) {
+    console.log(`Done: ${copied + created} copied, ${skipped} unchanged`);
+  } else {
+    console.log(`Updated: ${copied}, Created: ${created}`);
+  }
+  if (resolution === 'backup' && conflicts.length > 0) {
+    console.log(`Created ${conflicts.length} backup file(s)`);
+  }
+  if (targetLinesUpdated) {
+    console.log('Target files updated with required lines');
+  }
+  if (syncConfigCreated) {
+    console.log(`Created ${SYNC_CONFIG_FILENAME} for push customization`);
+  }
+  console.log(`${'='.repeat(60)}`);
+
+  if (isFirstTime) {
+    console.log('\nNext steps:');
+    console.log('  1. Commit the changes');
+  }
+
+  return 0;
+}

package/src/lib/constants.ts

@@ -0,0 +1,10 @@
+export const SYNC_CONFIG_FILENAME = '.allhands-sync-config.json';
+
+// Files that should never be pushed back to upstream
+export const PUSH_BLOCKLIST = ['CLAUDE.project.md', '.allhands-sync-config.json'];
+
+export const SYNC_CONFIG_TEMPLATE = {
+  $comment: 'Customization for claude-all-hands push command',
+  includes: [],
+  excludes: [],
+};

package/src/lib/dotfiles.ts

@@ -0,0 +1,36 @@
+import { existsSync, renameSync } from 'fs';
+import { basename, dirname, join } from 'path';
+import { walkDir } from './fs-utils.js';
+
+// Files that npm hardcode-excludes and we rename for packaging
+const DOTFILE_NAMES = ['gitignore', 'npmrc', 'npmignore'];
+
+/**
+ * Restore dotfiles after copying from npm package.
+ * Renames `gitignore` → `.gitignore`, `npmrc` → `.npmrc`, etc.
+ * Returns count of files renamed.
+ */
+export function restoreDotfiles(targetDir: string): { renamed: string[]; skipped: string[] } {
+  const renamed: string[] = [];
+  const skipped: string[] = [];
+
+  walkDir(targetDir, (filePath) => {
+    const name = basename(filePath);
+
+    if (DOTFILE_NAMES.includes(name)) {
+      const dir = dirname(filePath);
+      const dotName = '.' + name;
+      const dotPath = join(dir, dotName);
+
+      if (existsSync(dotPath)) {
+        // Target dotfile already exists - skip to avoid overwriting
+        skipped.push(filePath);
+      } else {
+        renameSync(filePath, dotPath);
+        renamed.push(filePath);
+      }
+    }
+  });
+
+  return { renamed, skipped };
+}

package/src/lib/fs-utils.ts

@@ -0,0 +1,18 @@
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+export function walkDir(dir: string, callback: (filePath: string) => void): void {
+  if (!existsSync(dir)) return;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === '.git' || entry.name === 'node_modules') {
+      continue;
+    }
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkDir(fullPath, callback);
+    } else if (entry.isFile()) {
+      callback(fullPath);
+    }
+  }
+}

package/src/lib/gh.ts

@@ -0,0 +1,40 @@
+import { execSync, spawnSync } from 'child_process';
+
+export interface GhResult {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+}
+
+export function gh(args: string[], cwd?: string): GhResult {
+  const result = spawnSync('gh', args, {
+    cwd: cwd || process.cwd(),
+    encoding: 'utf-8',
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  return {
+    success: result.status === 0,
+    stdout: result.stdout?.trim() || '',
+    stderr: result.stderr?.trim() || '',
+  };
+}
+
+export function checkGhInstalled(): boolean {
+  try {
+    execSync('gh --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function checkGhAuth(): boolean {
+  const result = gh(['auth', 'status']);
+  return result.success;
+}
+
+export function getGhUser(): string | null {
+  const result = gh(['api', 'user', '-q', '.login']);
+  return result.success ? result.stdout : null;
+}

package/src/lib/git.ts

@@ -0,0 +1,63 @@
+import { execSync, spawnSync } from 'child_process';
+
+export interface GitResult {
+  success: boolean;
+  stdout: string;
+  stderr: string;
+}
+
+export function git(args: string[], cwd: string): GitResult {
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf-8',
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  return {
+    success: result.status === 0,
+    stdout: result.stdout?.trim() || '',
+    stderr: result.stderr?.trim() || '',
+  };
+}
+
+export function getStagedFiles(repoPath: string): Set<string> {
+  const result = git(['diff', '--cached', '--name-only'], repoPath);
+  if (!result.success || !result.stdout) {
+    return new Set();
+  }
+  return new Set(result.stdout.split('\n').filter(Boolean));
+}
+
+export function isGitRepo(path: string): boolean {
+  const result = git(['rev-parse', '--git-dir'], path);
+  return result.success;
+}
+
+export function checkGitInstalled(): boolean {
+  try {
+    execSync('git --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get all files tracked by git plus untracked files, excluding gitignored files.
+ * This respects .gitignore at all levels.
+ */
+export function getGitFiles(repoPath: string): string[] {
+  // Get tracked files
+  const tracked = git(['ls-files'], repoPath);
+  // Get untracked files that are NOT ignored
+  const untracked = git(['ls-files', '--others', '--exclude-standard'], repoPath);
+
+  const files: string[] = [];
+  if (tracked.success && tracked.stdout) {
+    files.push(...tracked.stdout.split('\n').filter(Boolean));
+  }
+  if (untracked.success && untracked.stdout) {
+    files.push(...untracked.stdout.split('\n').filter(Boolean));
+  }
+  return files;
+}

package/src/lib/gitignore.ts

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, relative, dirname } from 'path';
+import { minimatch } from 'minimatch';
+import { walkDir } from './fs-utils.js';
+
+interface GitignoreRule {
+  pattern: string;
+  negated: boolean;
+  directory: string; // Directory where the .gitignore lives (relative to root)
+}
+
+/**
+ * Parse a single .gitignore file and return rules.
+ */
+function parseGitignoreFile(content: string, directory: string): GitignoreRule[] {
+  const rules: GitignoreRule[] = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Skip empty lines and comments
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue;
+    }
+
+    let pattern = trimmed;
+    let negated = false;
+
+    // Handle negation
+    if (pattern.startsWith('!')) {
+      negated = true;
+      pattern = pattern.slice(1);
+    }
+
+    // Remove trailing spaces (unless escaped)
+    pattern = pattern.replace(/(?<!\\)\s+$/, '');
+
+    // Skip empty patterns after processing
+    if (!pattern) continue;
+
+    rules.push({ pattern, negated, directory });
+  }
+
+  return rules;
+}
+
+/**
+ * Check if a file path matches a gitignore pattern.
+ * Handles directory-relative patterns correctly.
+ */
+function matchesPattern(filePath: string, rule: GitignoreRule): boolean {
+  const { pattern, directory } = rule;
+
+  // Get the path relative to the gitignore's directory
+  let relativePath = filePath;
+  if (directory) {
+    if (!filePath.startsWith(directory + '/') && filePath !== directory) {
+      // File is not under this gitignore's directory
+      return false;
+    }
+    relativePath = filePath.slice(directory.length + 1);
+  }
+
+  // Handle patterns that should only match from root of gitignore dir
+  let matchPattern = pattern;
+
+  // Pattern starting with / means root-relative
+  if (pattern.startsWith('/')) {
+    matchPattern = pattern.slice(1);
+  }
+
+  // Pattern ending with / means directory only (we treat all as potential matches)
+  if (matchPattern.endsWith('/')) {
+    matchPattern = matchPattern.slice(0, -1) + '/**';
+  }
+
+  // If pattern has no slash, it can match at any level
+  // If pattern has slash (not just trailing), it's relative to gitignore location
+  const hasSlash = pattern.includes('/') && !pattern.endsWith('/');
+
+  if (!hasSlash && !pattern.startsWith('/')) {
+    // Match at any level: foo matches a/b/foo and foo
+    matchPattern = '**/' + matchPattern;
+  }
+
+  // Try matching
+  const opts = { dot: true, matchBase: false };
+
+  if (minimatch(relativePath, matchPattern, opts)) {
+    return true;
+  }
+
+  // Also try with ** suffix for directories
+  if (minimatch(relativePath, matchPattern + '/**', opts)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Collector class that gathers all .gitignore rules from a directory tree.
+ */
+export class GitignoreFilter {
+  private rules: GitignoreRule[] = [];
+  private rootDir: string;
+
+  constructor(rootDir: string) {
+    this.rootDir = rootDir;
+    this.loadGitignoreFiles();
+  }
+
+  /**
+   * Walk the directory tree and load all .gitignore files.
+   */
+  private loadGitignoreFiles(): void {
+    // Check root .gitignore
+    const rootGitignore = join(this.rootDir, '.gitignore');
+    if (existsSync(rootGitignore)) {
+      const content = readFileSync(rootGitignore, 'utf-8');
+      this.rules.push(...parseGitignoreFile(content, ''));
+    }
+
+    // Walk and find nested .gitignore files
+    walkDir(this.rootDir, (filePath) => {
+      const relativePath = relative(this.rootDir, filePath);
+      if (relativePath.endsWith('.gitignore') && relativePath !== '.gitignore') {
+        const content = readFileSync(filePath, 'utf-8');
+        const directory = dirname(relativePath);
+        this.rules.push(...parseGitignoreFile(content, directory));
+      }
+    });
+  }
+
+  /**
+   * Check if a file should be ignored based on all gitignore rules.
+   */
+  isIgnored(filePath: string): boolean {
+    let ignored = false;
+
+    // Process rules in order - later rules can override earlier ones
+    for (const rule of this.rules) {
+      if (matchesPattern(filePath, rule)) {
+        ignored = !rule.negated;
+      }
+    }
+
+    return ignored;
+  }
+
+  /**
+   * Get all non-ignored files from the directory tree.
+   */
+  getNonIgnoredFiles(): string[] {
+    const files: string[] = [];
+
+    walkDir(this.rootDir, (filePath) => {
+      const relativePath = relative(this.rootDir, filePath);
+      if (!this.isIgnored(relativePath)) {
+        files.push(relativePath);
+      }
+    });
+
+    return files;
+  }
+}