drybase 1.0.0

package/src/core/syncer.js

@@ -0,0 +1,320 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as git from './git.js';
+import * as github from './github.js';
+import * as differ from '../utils/differ.js';
+import * as stateUtil from '../utils/state.js';
+import { runTests } from '../utils/test-runner.js';
+import * as logger from '../utils/logger.js';
+
+/**
+ * Maps changed files from base watch paths to target sync path.
+ * Strips the watchPath root and prepends syncPath.
+ *
+ * E.g., watchPaths=["src/shared"], file="src/shared/utils/logger.js", syncPath="lib/base"
+ *       → "lib/base/utils/logger.js"
+ */
+export function buildFileMapping(watchPaths, changedFiles, syncPath) {
+  const mapping = {};
+  for (const file of changedFiles) {
+    for (const wp of watchPaths) {
+      const normalized = wp.replace(/\/$/, '');
+      if (file === normalized || file.startsWith(normalized + '/')) {
+        const relative = file.slice(normalized.length).replace(/^\//, '');
+        const target = relative ? path.join(syncPath, relative) : syncPath;
+        mapping[file] = target;
+        break;
+      }
+    }
+  }
+  return mapping;
+}
+
+/**
+ * Discovers which files from the base repo have changed since the last sync.
+ */
+export async function getSyncableFiles(config, state, repoName) {
+  const baseDir = config.baseRepo.path;
+  const watchPaths = config.baseRepo.watchPaths;
+  const lastSync = stateUtil.getLastSync(state, repoName);
+
+  // Collect all files under each watchPath
+  const allFiles = [];
+  for (const wp of watchPaths) {
+    const fullWp = path.resolve(baseDir, wp);
+    const files = await collectFiles(fullWp, baseDir);
+    allFiles.push(...files);
+  }
+
+  if (!lastSync) {
+    // First sync — all files are new
+    return allFiles;
+  }
+
+  // Compare hashes with last sync
+  const currentHashes = await differ.computeHashMap(baseDir, allFiles);
+  const lastHashes = {};
+  if (lastSync.files) {
+    for (const [relPath, info] of Object.entries(lastSync.files)) {
+      lastHashes[relPath] = info.hash;
+    }
+  }
+
+  const changed = [];
+  for (const file of allFiles) {
+    const lastHash = lastHashes[file];
+    if (!lastHash || lastHash !== currentHashes[file]) {
+      changed.push(file);
+    }
+  }
+
+  return changed;
+}
+
+/**
+ * Recursively collect all files under a directory, returning paths relative to baseDir.
+ */
+async function collectFiles(dir, baseDir) {
+  const files = [];
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    if (entry.isDirectory()) {
+      files.push(...(await collectFiles(fullPath, baseDir)));
+    } else if (entry.isFile()) {
+      files.push(path.relative(baseDir, fullPath));
+    }
+  }
+  return files;
+}
+
+/**
+ * Sync changed files to a single target repo.
+ */
+export async function syncToRepo(config, targetRepo, changedFiles, state, options = {}) {
+  const { dryRun = false, force = false } = options;
+  const baseDir = config.baseRepo.path;
+  const repoName = targetRepo.name;
+  const targetDir = targetRepo.localPath;
+  let syncMode = targetRepo.syncMode || 'pr-always';
+  const targetBranch = targetRepo.branch || 'main';
+
+  if (!changedFiles.length) {
+    logger.info(`No changes to sync to ${repoName}`);
+    return { repo: repoName, status: 'no-changes', files: [] };
+  }
+
+  // Build file mapping
+  const mapping = buildFileMapping(config.baseRepo.watchPaths, changedFiles, targetRepo.syncPath);
+  const mappedEntries = Object.entries(mapping);
+
+  logger.info(`Syncing ${mappedEntries.length} file(s) to ${repoName}`);
+
+  // Divergence detection
+  if (!force) {
+    const lastSync = stateUtil.getLastSync(state, repoName);
+    if (lastSync?.files) {
+      const targetRelPaths = mappedEntries.map(([, t]) => t);
+      const currentTargetHashes = await differ.computeHashMap(targetDir, targetRelPaths);
+      const lastSyncTargetHashes = {};
+      for (const [srcFile, targetFile] of mappedEntries) {
+        const lastFileInfo = lastSync.files[srcFile];
+        if (lastFileInfo?.targetHash) {
+          lastSyncTargetHashes[targetFile] = lastFileInfo.targetHash;
+        }
+      }
+      const diverged = differ.detectDivergence(lastSyncTargetHashes, currentTargetHashes);
+      if (diverged.length) {
+        logger.warn(`Divergence detected in ${repoName}: ${diverged.join(', ')}`);
+        logger.warn('Target files were manually edited. Upgrading to pr-always mode.');
+        syncMode = 'pr-always';
+      }
+    }
+  }
+
+  if (dryRun) {
+    logger.info('[DRY RUN] Would sync:');
+    for (const [src, target] of mappedEntries) {
+      logger.dim(`  ${src} → ${target}`);
+    }
+    return { repo: repoName, status: 'dry-run', files: changedFiles };
+  }
+
+  // Copy files to target
+  for (const [srcRel, targetRel] of mappedEntries) {
+    const srcFull = path.resolve(baseDir, srcRel);
+    const targetFull = path.resolve(targetDir, targetRel);
+    await fs.mkdir(path.dirname(targetFull), { recursive: true });
+    await fs.copyFile(srcFull, targetFull);
+    logger.debug(`  Copied ${srcRel} → ${targetRel}`);
+  }
+
+  // Build commit message
+  const fileList = mappedEntries.map(([s]) => path.basename(s)).join(', ');
+  const template = config.options?.commitMessageTemplate || 'Sync base code: {{files}}';
+  const commitMessage = template.replace('{{files}}', fileList);
+
+  // Execute sync mode strategy
+  const targetFiles = mappedEntries.map(([, t]) => t);
+
+  if (syncMode === 'direct') {
+    return await syncDirect(targetDir, targetFiles, commitMessage, repoName, targetBranch, changedFiles, baseDir, mapping, config, state);
+  } else if (syncMode === 'auto-if-tests-pass') {
+    return await syncAutoIfTestsPass(targetDir, targetFiles, commitMessage, repoName, targetBranch, changedFiles, baseDir, mapping, config, state);
+  } else {
+    // pr-always
+    return await syncPRAlways(targetDir, targetFiles, commitMessage, repoName, targetBranch, changedFiles, baseDir, mapping, config, state);
+  }
+}
+
+async function buildFileHashes(baseDir, mapping) {
+  const files = {};
+  for (const [srcRel, targetRel] of Object.entries(mapping)) {
+    const hash = await differ.computeFileHash(path.resolve(baseDir, srcRel));
+    files[srcRel] = { hash, action: 'modified', targetHash: hash };
+  }
+  return files;
+}
+
+async function syncDirect(targetDir, targetFiles, commitMessage, repoName, targetBranch, changedFiles, baseDir, mapping, config, state) {
+  await git.checkoutBranch(targetDir, targetBranch);
+  const commitSha = await git.commitFiles(targetDir, targetFiles, commitMessage);
+  await git.pushBranch(targetDir, targetBranch);
+
+  const fileHashes = await buildFileHashes(baseDir, mapping);
+  const newState = stateUtil.recordSync(state, {
+    repo: repoName,
+    files: fileHashes,
+    commitSha,
+    status: 'success',
+  });
+  await stateUtil.saveState(config._configDir, newState);
+
+  logger.success(`Direct sync to ${repoName} complete (${commitSha})`);
+  return { repo: repoName, status: 'success', commitSha, files: changedFiles };
+}
+
+async function syncAutoIfTestsPass(targetDir, targetFiles, commitMessage, repoName, targetBranch, changedFiles, baseDir, mapping, config, state) {
+  const branchPrefix = config.options?.branchPrefix || 'sync-bot';
+  const syncBranch = `${branchPrefix}/${Date.now()}`;
+
+  await git.createBranch(targetDir, syncBranch, targetBranch);
+  const commitSha = await git.commitFiles(targetDir, targetFiles, commitMessage);
+  await git.pushBranch(targetDir, syncBranch);
+
+  // Run tests
+  const testCommand = config.options?.testCommand || 'npm test';
+  const runTestsEnabled = config.options?.runTests !== false;
+
+  if (runTestsEnabled) {
+    const { passed, output } = await runTests(testCommand, targetDir);
+
+    if (passed && config.options?.autoMergeOnPass !== false) {
+      // Tests passed — auto merge
+      await git.checkoutBranch(targetDir, targetBranch);
+      const mergeGit = git.getGit(targetDir);
+      await mergeGit.merge([syncBranch]);
+      await git.pushBranch(targetDir, targetBranch);
+
+      const fileHashes = await buildFileHashes(baseDir, mapping);
+      const newState = stateUtil.recordSync(state, {
+        repo: repoName,
+        files: fileHashes,
+        commitSha,
+        status: 'success',
+      });
+      await stateUtil.saveState(config._configDir, newState);
+
+      logger.success(`Tests passed! Auto-merged sync to ${repoName}`);
+      return { repo: repoName, status: 'success', commitSha, files: changedFiles };
+    }
+
+    // Tests failed — fall through to PR creation
+    logger.warn(`Tests failed for ${repoName}. Creating PR for review.`);
+  }
+
+  // Create PR
+  return await createSyncPR(repoName, syncBranch, targetBranch, commitMessage, changedFiles, commitSha, baseDir, mapping, config, state);
+}
+
+async function syncPRAlways(targetDir, targetFiles, commitMessage, repoName, targetBranch, changedFiles, baseDir, mapping, config, state) {
+  const branchPrefix = config.options?.branchPrefix || 'sync-bot';
+  const syncBranch = `${branchPrefix}/${Date.now()}`;
+
+  await git.createBranch(targetDir, syncBranch, targetBranch);
+  const commitSha = await git.commitFiles(targetDir, targetFiles, commitMessage);
+  await git.pushBranch(targetDir, syncBranch);
+
+  return await createSyncPR(repoName, syncBranch, targetBranch, commitMessage, changedFiles, commitSha, baseDir, mapping, config, state);
+}
+
+async function createSyncPR(repoName, syncBranch, targetBranch, commitMessage, changedFiles, commitSha, baseDir, mapping, config, state) {
+  const fileList = changedFiles.map((f) => `- \`${f}\``).join('\n');
+  const body = `## Automated Base Code Sync\n\n**Files synced:**\n${fileList}\n\n*Created by drybase*`;
+
+  const pr = await github.createPullRequest({
+    repoName,
+    title: commitMessage,
+    body,
+    head: syncBranch,
+    base: targetBranch,
+    labels: ['automated-sync'],
+  });
+
+  const fileHashes = await buildFileHashes(baseDir, mapping);
+  const newState = stateUtil.recordSync(state, {
+    repo: repoName,
+    files: fileHashes,
+    commitSha,
+    status: 'pr-created',
+  });
+  await stateUtil.saveState(config._configDir, newState);
+
+  logger.success(`Created PR #${pr.number} for ${repoName}`);
+  return { repo: repoName, status: 'pr-created', prNumber: pr.number, commitSha, files: changedFiles };
+}
+
+/**
+ * Sync to all (or filtered) target repos.
+ */
+export async function syncAll(config, options = {}) {
+  const { repo: repoFilter, dryRun = false, force = false } = options;
+  const state = await stateUtil.loadState(config._configDir);
+
+  github.initOctokit(config.github.token);
+
+  const targets = repoFilter
+    ? config.targetRepos.filter((r) => r.name === repoFilter)
+    : config.targetRepos;
+
+  if (!targets.length) {
+    if (repoFilter) {
+      logger.error(`No target repo matching "${repoFilter}"`);
+    } else {
+      logger.warn('No target repos configured');
+    }
+    return [];
+  }
+
+  const results = [];
+  for (const target of targets) {
+    try {
+      const changedFiles = await getSyncableFiles(config, state, target.name);
+      const result = await syncToRepo(config, target, changedFiles, state, { dryRun, force });
+      results.push(result);
+    } catch (err) {
+      logger.error(`Sync to ${target.name} failed: ${err.message}`);
+      logger.debug(err.stack);
+      results.push({ repo: target.name, status: 'failed', error: err.message });
+    }
+  }
+
+  return results;
+}

package/src/core/watcher.js

@@ -0,0 +1,92 @@
+import chokidar from 'chokidar';
+import path from 'node:path';
+import * as logger from '../utils/logger.js';
+import { syncAll } from './syncer.js';
+
+const DEBOUNCE_MS = 2000;
+const IGNORE_PATTERNS = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/drybase.json',
+  '**/.drybase-state.json',
+  '**/.DS_Store',
+];
+
+export function createWatcher(config) {
+  const baseDir = config.baseRepo.path;
+  const watchPaths = config.baseRepo.watchPaths.map((wp) => path.resolve(baseDir, wp));
+
+  const changedFiles = new Set();
+  let debounceTimer = null;
+  let syncing = false;
+
+  const watcher = chokidar.watch(watchPaths, {
+    ignored: IGNORE_PATTERNS,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 500 },
+  });
+
+  async function processBatch() {
+    if (syncing || changedFiles.size === 0) return;
+    syncing = true;
+
+    const files = [...changedFiles];
+    changedFiles.clear();
+
+    // Convert absolute paths to relative from baseDir
+    const relativePaths = files.map((f) => path.relative(baseDir, f));
+
+    logger.info(`Detected ${relativePaths.length} changed file(s)`);
+    for (const f of relativePaths) {
+      logger.dim(`  ${f}`);
+    }
+
+    try {
+      await syncAll(config, {});
+    } catch (err) {
+      logger.error(`Sync failed: ${err.message}`);
+      logger.debug(err.stack);
+    } finally {
+      syncing = false;
+      // Process any files that changed during sync
+      if (changedFiles.size > 0) {
+        scheduleBatch();
+      }
+    }
+  }
+
+  function scheduleBatch() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(processBatch, DEBOUNCE_MS);
+  }
+
+  function onFileChange(eventType, filePath) {
+    changedFiles.add(filePath);
+    logger.debug(`${eventType}: ${filePath}`);
+    scheduleBatch();
+  }
+
+  watcher
+    .on('add', (p) => onFileChange('add', p))
+    .on('change', (p) => onFileChange('change', p))
+    .on('unlink', (p) => onFileChange('delete', p));
+
+  watcher.on('ready', () => {
+    logger.success('Watching for changes...');
+    for (const wp of watchPaths) {
+      logger.dim(`  ${wp}`);
+    }
+  });
+
+  watcher.on('error', (err) => {
+    logger.error(`Watcher error: ${err.message}`);
+  });
+
+  return {
+    close() {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      return watcher.close();
+    },
+  };
+}

package/src/index.js

@@ -0,0 +1,117 @@
+import { Command } from 'commander';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const program = new Command();
+
+program
+  .name('drybase')
+  .description('Monitor file changes in a base repository and sync to multiple targets')
+  .version('1.0.0');
+
+// Lazy-load commands to keep startup fast
+program
+  .command('init')
+  .description('Initialize a new drybase.json configuration')
+  .action(async () => {
+    const { initCommand } = await import('./commands/init.js');
+    await initCommand();
+  });
+
+program
+  .command('onboard')
+  .description('LLM-powered project analysis and config generation')
+  .argument('[path]', 'Path to project to analyze', '.')
+  .option('--interactive', 'Interactive mode for accepting/rejecting suggestions')
+  .option('--no-llm', 'Skip LLM analysis, use manual mode')
+  .action(async (path, options) => {
+    const { onboardCommand } = await import('./commands/onboard.js');
+    await onboardCommand(path, options);
+  });
+
+program
+  .command('watch')
+  .description('Watch for file changes and sync in foreground')
+  .action(async () => {
+    const { watchCommand } = await import('./commands/watch.js');
+    await watchCommand();
+  });
+
+program
+  .command('start')
+  .description('Start the sync daemon in background')
+  .action(async () => {
+    const { startCommand } = await import('./commands/start.js');
+    await startCommand();
+  });
+
+program
+  .command('stop')
+  .description('Stop the sync daemon')
+  .action(async () => {
+    const { stopCommand } = await import('./commands/stop.js');
+    await stopCommand();
+  });
+
+program
+  .command('sync')
+  .description('Run a one-time sync')
+  .option('--repo <name>', 'Sync only to a specific repo (owner/name)')
+  .option('--dry-run', 'Preview changes without syncing')
+  .option('--force', 'Skip divergence checks')
+  .action(async (options) => {
+    const { syncCommand } = await import('./commands/sync.js');
+    await syncCommand(options);
+  });
+
+program
+  .command('status')
+  .description('Show sync status for all target repos')
+  .action(async () => {
+    const { statusCommand } = await import('./commands/status.js');
+    await statusCommand();
+  });
+
+program
+  .command('history')
+  .description('Show sync history')
+  .option('--repo <name>', 'Filter by repo (owner/name)')
+  .option('--limit <n>', 'Number of entries to show', '20')
+  .action(async (options) => {
+    const { historyCommand } = await import('./commands/history.js');
+    await historyCommand(options);
+  });
+
+program
+  .command('rollback')
+  .description('Rollback the last sync for a repo')
+  .argument('<repo>', 'Target repo name (owner/name)')
+  .option('--yes', 'Skip confirmation prompt')
+  .action(async (repo, options) => {
+    const { rollbackCommand } = await import('./commands/rollback.js');
+    await rollbackCommand(repo, options);
+  });
+
+program
+  .command('validate')
+  .description('Validate the drybase.json configuration')
+  .action(async () => {
+    const { validateCommand } = await import('./commands/validate.js');
+    await validateCommand();
+  });
+
+// Global error handling
+process.on('unhandledRejection', (err) => {
+  console.error('Unhandled error:', err.message || err);
+  if (process.env.DRYBASE_DEBUG) console.error(err.stack);
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Fatal error:', err.message || err);
+  if (process.env.DRYBASE_DEBUG) console.error(err.stack);
+  process.exit(1);
+});
+
+program.parse();

package/src/utils/config.js

@@ -0,0 +1,141 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+
+const CONFIG_NAME = 'drybase.json';
+
+export function resolveEnvValue(value) {
+  if (typeof value === 'string' && value.startsWith('env:')) {
+    const varName = value.slice(4);
+    const resolved = process.env[varName];
+    if (!resolved) {
+      throw new Error(`Environment variable ${varName} is not set (referenced as "${value}")`);
+    }
+    return resolved;
+  }
+  return value;
+}
+
+export async function findConfigFile() {
+  // 1. Environment variable override
+  if (process.env.DRYBASE_CONFIG) {
+    try {
+      await fs.access(process.env.DRYBASE_CONFIG);
+      return path.resolve(process.env.DRYBASE_CONFIG);
+    } catch {
+      throw new Error(`Config file not found at DRYBASE_CONFIG path: ${process.env.DRYBASE_CONFIG}`);
+    }
+  }
+
+  // 2. Current working directory
+  const cwdConfig = path.resolve(process.cwd(), CONFIG_NAME);
+  try {
+    await fs.access(cwdConfig);
+    return cwdConfig;
+  } catch {
+    // continue
+  }
+
+  // 3. Git root traversal
+  try {
+    const gitRoot = execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    const gitConfig = path.join(gitRoot, CONFIG_NAME);
+    try {
+      await fs.access(gitConfig);
+      return gitConfig;
+    } catch {
+      // continue
+    }
+  } catch {
+    // Not in a git repo — skip
+  }
+
+  // 4. Home directory
+  const homeConfig = path.join(os.homedir(), CONFIG_NAME);
+  try {
+    await fs.access(homeConfig);
+    return homeConfig;
+  } catch {
+    // continue
+  }
+
+  return null;
+}
+
+export async function loadConfig(configPath) {
+  const filePath = configPath || (await findConfigFile());
+  if (!filePath) {
+    return null;
+  }
+
+  const raw = await fs.readFile(filePath, 'utf8');
+  const config = JSON.parse(raw);
+  config._configPath = filePath;
+  config._configDir = path.dirname(filePath);
+
+  // Resolve relative paths
+  if (config.baseRepo?.path) {
+    config.baseRepo.path = path.resolve(config._configDir, config.baseRepo.path);
+  }
+  for (const repo of config.targetRepos || []) {
+    if (repo.localPath) {
+      repo.localPath = path.resolve(config._configDir, repo.localPath);
+    }
+  }
+
+  // Resolve env: values for secrets
+  if (config.github?.token) {
+    config.github.token = resolveEnvValue(config.github.token);
+  }
+  if (config.llm?.apiKey) {
+    config.llm.apiKey = resolveEnvValue(config.llm.apiKey);
+  }
+
+  return config;
+}
+
+export function validateConfig(config) {
+  const errors = [];
+
+  if (!config) {
+    return ['No configuration provided'];
+  }
+
+  // baseRepo
+  if (!config.baseRepo) {
+    errors.push('Missing "baseRepo" section');
+  } else {
+    if (!config.baseRepo.path) errors.push('Missing "baseRepo.path"');
+    if (!config.baseRepo.watchPaths || !config.baseRepo.watchPaths.length) {
+      errors.push('Missing or empty "baseRepo.watchPaths"');
+    }
+  }
+
+  // github
+  if (!config.github) {
+    errors.push('Missing "github" section');
+  } else if (!config.github.token) {
+    errors.push('Missing "github.token"');
+  }
+
+  // targetRepos
+  if (!config.targetRepos || !config.targetRepos.length) {
+    errors.push('Missing or empty "targetRepos"');
+  } else {
+    for (const [i, repo] of config.targetRepos.entries()) {
+      const prefix = `targetRepos[${i}]`;
+      if (!repo.name) errors.push(`${prefix}: missing "name"`);
+      if (!repo.localPath) errors.push(`${prefix}: missing "localPath"`);
+      if (!repo.syncPath) errors.push(`${prefix}: missing "syncPath"`);
+      if (repo.syncMode && !['direct', 'auto-if-tests-pass', 'pr-always'].includes(repo.syncMode)) {
+        errors.push(`${prefix}: invalid syncMode "${repo.syncMode}". Must be direct, auto-if-tests-pass, or pr-always`);
+      }
+    }
+  }
+
+  return errors.length ? errors : null;
+}