drybase 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tristan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# DryBase
+
+CLI tool that monitors file changes in a "base" repository and automatically syncs those changes to multiple target repositories — eliminating the need for npm/composer packages for shared code.
+
+## Installation
+
+```bash
+npm install -g drybase
+```
+
+## Quick Start
+
+```bash
+# 1. Initialize config in your base repo
+cd /path/to/base-repo
+drybase init
+
+# 2. Validate configuration
+drybase validate
+
+# 3. Preview what would sync
+drybase sync --dry-run
+
+# 4. Run a one-time sync
+drybase sync
+
+# 5. Watch for changes (foreground)
+drybase watch
+
+# 6. Or run as a daemon
+drybase start
+drybase stop
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `drybase init` | Interactive config creation |
+| `drybase onboard [path]` | LLM-powered project analysis |
+| `drybase validate` | Validate configuration |
+| `drybase sync [--repo] [--dry-run] [--force]` | One-time sync |
+| `drybase watch` | Watch and sync in foreground |
+| `drybase start` / `stop` | Daemon lifecycle |
+| `drybase status` | Show per-repo sync status |
+| `drybase history [--repo] [--limit]` | Show sync history |
+| `drybase rollback <repo> [--yes]` | Revert last sync |
+
+## Configuration
+
+Create `drybase.json` in your base repository root:
+
+```json
+{
+  "baseRepo": {
+    "path": ".",
+    "watchPaths": ["src/shared", "config/base"]
+  },
+  "github": {
+    "token": "env:GITHUB_TOKEN"
+  },
+  "targetRepos": [
+    {
+      "name": "owner/repo",
+      "localPath": "/path/to/repo",
+      "syncPath": "src/base",
+      "syncMode": "auto-if-tests-pass",
+      "branch": "main"
+    }
+  ],
+  "options": {
+    "commitMessageTemplate": "Sync base code: {{files}}",
+    "branchPrefix": "sync-bot",
+    "autoMergeOnPass": true,
+    "runTests": true
+  }
+}
+```
+
+## Sync Modes
+
+- **`direct`** — Commit directly to target branch (fastest, riskiest)
+- **`auto-if-tests-pass`** — Create sync branch, run tests, auto-merge if green
+- **`pr-always`** — Always create a PR for manual review
+
+## LLM Providers
+
+The `onboard` command supports multiple LLM providers via Vercel AI SDK:
+
+- Anthropic (Claude)
+- OpenAI (GPT-4)
+- Google (Gemini)
+- Mistral
+- Ollama (local models)
+- Any OpenAI-compatible API
+
+## Environment Variables
+
+```bash
+GITHUB_TOKEN=ghp_...          # Required for GitHub operations
+ANTHROPIC_API_KEY=sk-ant-...  # For Claude
+OPENAI_API_KEY=sk-...         # For GPT
+DRYBASE_DEBUG=1               # Enable debug logging
+DRYBASE_CONFIG=/path/to/conf  # Custom config path
+```
+
+## License
+
+MIT

package/bin/drybase.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../src/index.js';

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "drybase",
+  "version": "1.0.0",
+  "description": "CLI tool that monitors file changes in a base repository and syncs to multiple target repositories",
+  "type": "module",
+  "bin": {
+    "drybase": "./bin/drybase.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": ["cli", "sync", "git", "monorepo", "dry", "shared-code", "file-sync"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tristandewit/drybase.git"
+  },
+  "homepage": "https://github.com/tristandewit/drybase#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^1",
+    "@ai-sdk/openai": "^1",
+    "@octokit/rest": "^22",
+    "ai": "^4",
+    "chalk": "^5",
+    "chokidar": "^4",
+    "commander": "^14",
+    "dotenv": "^16",
+    "inquirer": "^12",
+    "simple-git": "^3"
+  },
+  "devDependencies": {
+    "vitest": "^3"
+  }
+}

package/src/commands/history.js

@@ -0,0 +1,38 @@
+import { loadConfig } from '../utils/config.js';
+import { loadState } from '../utils/state.js';
+import * as logger from '../utils/logger.js';
+
+export async function historyCommand(options) {
+  const config = await loadConfig();
+  if (!config) {
+    logger.error('No drybase.json found. Run "drybase init" to create one.');
+    process.exit(1);
+  }
+
+  const state = await loadState(config._configDir);
+  let history = state.syncHistory || [];
+
+  if (options.repo) {
+    history = history.filter((h) => h.repo === options.repo);
+  }
+
+  const limit = parseInt(options.limit, 10) || 20;
+  history = history.slice(0, limit);
+
+  if (!history.length) {
+    logger.info('No sync history found.');
+    return;
+  }
+
+  logger.info(`Sync History (last ${history.length})\n`);
+
+  const rows = history.map((entry) => ({
+    ID: entry.id,
+    Repo: entry.repo,
+    Time: new Date(entry.timestamp).toLocaleString(),
+    Files: entry.files?.length || 0,
+    Status: entry.status,
+  }));
+
+  logger.table(rows);
+}

package/src/commands/init.js

@@ -0,0 +1,171 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import inquirer from 'inquirer';
+import * as logger from '../utils/logger.js';
+
+export async function initCommand() {
+  // Detect git root
+  let gitRoot = null;
+  try {
+    gitRoot = execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    logger.success(`Detected git repository root: ${gitRoot}`);
+  } catch {
+    logger.warn('Not in a git repository. Config will be created in current directory.');
+  }
+
+  const configDir = gitRoot || process.cwd();
+  const configPath = path.join(configDir, 'drybase.json');
+
+  // Check if config already exists
+  try {
+    await fs.access(configPath);
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: 'drybase.json already exists. Overwrite?',
+        default: false,
+      },
+    ]);
+    if (!overwrite) {
+      logger.info('Cancelled.');
+      return;
+    }
+  } catch {
+    // Doesn't exist — good
+  }
+
+  // Base repo path
+  const { basePath } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'basePath',
+      message: 'Where is your base code?',
+      choices: [
+        { name: `Current directory (${configDir})`, value: configDir },
+        { name: 'Specify custom path', value: '__custom__' },
+      ],
+    },
+  ]);
+
+  let resolvedBasePath = basePath;
+  if (basePath === '__custom__') {
+    const { customPath } = await inquirer.prompt([
+      { type: 'input', name: 'customPath', message: 'Enter base repo path:' },
+    ]);
+    resolvedBasePath = path.resolve(customPath);
+  }
+
+  // Watch paths
+  const { watchPathsInput } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'watchPathsInput',
+      message: 'Which folders contain base code to sync? (comma-separated)',
+      default: 'src/shared',
+    },
+  ]);
+  const watchPaths = watchPathsInput.split(',').map((p) => p.trim()).filter(Boolean);
+
+  // GitHub token
+  const { tokenSource } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'tokenSource',
+      message: 'GitHub token configuration:',
+      choices: [
+        { name: 'Use environment variable (GITHUB_TOKEN)', value: 'env:GITHUB_TOKEN' },
+        { name: 'Enter token directly', value: '__direct__' },
+      ],
+    },
+  ]);
+
+  let token = tokenSource;
+  if (tokenSource === '__direct__') {
+    const { directToken } = await inquirer.prompt([
+      { type: 'password', name: 'directToken', message: 'GitHub personal access token:' },
+    ]);
+    token = directToken;
+  }
+
+  // Target repos
+  const targetRepos = [];
+  let addMore = true;
+  while (addMore) {
+    const answers = await inquirer.prompt([
+      { type: 'input', name: 'name', message: 'Target repo (owner/name):' },
+      { type: 'input', name: 'localPath', message: 'Local path to target repo:' },
+      { type: 'input', name: 'syncPath', message: 'Sync destination path in target:', default: 'src/base' },
+      {
+        type: 'list',
+        name: 'syncMode',
+        message: 'Sync mode:',
+        choices: ['auto-if-tests-pass', 'pr-always', 'direct'],
+      },
+      { type: 'input', name: 'branch', message: 'Target branch:', default: 'main' },
+    ]);
+    targetRepos.push(answers);
+
+    const { more } = await inquirer.prompt([
+      { type: 'confirm', name: 'more', message: 'Add another target repo?', default: false },
+    ]);
+    addMore = more;
+  }
+
+  // LLM provider
+  const { llmProvider } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'llmProvider',
+      message: 'LLM provider for onboard command:',
+      choices: [
+        { name: 'Anthropic (Claude)', value: 'anthropic' },
+        { name: 'OpenAI (GPT-4)', value: 'openai' },
+        { name: 'Google (Gemini)', value: 'google' },
+        { name: 'Mistral', value: 'mistral' },
+        { name: 'Ollama (Local)', value: 'ollama' },
+        { name: 'Skip LLM setup', value: null },
+      ],
+    },
+  ]);
+
+  // Build config
+  const config = {
+    baseRepo: {
+      path: path.relative(configDir, resolvedBasePath) || '.',
+      watchPaths,
+    },
+    github: { token },
+    targetRepos,
+    options: {
+      commitMessageTemplate: 'Sync base code: {{files}}',
+      branchPrefix: 'sync-bot',
+      autoMergeOnPass: true,
+      runTests: true,
+    },
+  };
+
+  if (llmProvider) {
+    const modelDefaults = {
+      anthropic: { model: 'claude-sonnet-4-20250514', apiKey: 'env:ANTHROPIC_API_KEY' },
+      openai: { model: 'gpt-4-turbo', apiKey: 'env:OPENAI_API_KEY' },
+      google: { model: 'gemini-1.5-pro', apiKey: 'env:GOOGLE_API_KEY' },
+      mistral: { model: 'mistral-large-latest', apiKey: 'env:MISTRAL_API_KEY' },
+      ollama: { model: 'llama3.1', baseURL: 'http://localhost:11434' },
+    };
+    config.llm = { provider: llmProvider, ...modelDefaults[llmProvider] };
+  }
+
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
+  logger.success(`Created drybase.json in ${configDir}`);
+
+  logger.info('\nNext steps:');
+  logger.dim('  1. Review and edit drybase.json');
+  logger.dim('  2. Run: drybase validate');
+  logger.dim('  3. Run: drybase onboard (to auto-detect base files)');
+  logger.dim('     or: drybase watch (to start syncing)');
+}

package/src/commands/onboard.js

@@ -0,0 +1,185 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import inquirer from 'inquirer';
+import { loadConfig, findConfigFile } from '../utils/config.js';
+import { analyzeProject, scanProject } from '../core/analyzer.js';
+import * as logger from '../utils/logger.js';
+
+export async function onboardCommand(projectPath, options) {
+  const resolvedPath = path.resolve(projectPath);
+
+  // Check project exists
+  try {
+    await fs.access(resolvedPath);
+  } catch {
+    logger.error(`Project path not found: ${resolvedPath}`);
+    process.exit(1);
+  }
+
+  // Try to load existing config for LLM settings
+  let config;
+  try {
+    config = await loadConfig();
+  } catch {
+    // No config yet — that's fine for onboard
+  }
+
+  if (options.llm === false) {
+    logger.info('Skipping LLM analysis (--no-llm). Manual mode.');
+    await manualOnboard(resolvedPath);
+    return;
+  }
+
+  if (!config?.llm) {
+    logger.warn('No LLM provider configured. Falling back to manual mode.');
+    logger.dim('Tip: Run "drybase init" first, or add an "llm" section to drybase.json');
+    await manualOnboard(resolvedPath);
+    return;
+  }
+
+  let analysis;
+  try {
+    analysis = await analyzeProject(resolvedPath, config.llm);
+  } catch (err) {
+    logger.error(`LLM analysis failed: ${err.message}`);
+    logger.warn('Falling back to manual mode.');
+    await manualOnboard(resolvedPath);
+    return;
+  }
+
+  if (!analysis) {
+    await manualOnboard(resolvedPath);
+    return;
+  }
+
+  // Display results
+  const { baseFiles, recommendedWatchPaths } = analysis;
+
+  if (!baseFiles?.length) {
+    logger.info('No base files detected. Try manual mode with --no-llm.');
+    return;
+  }
+
+  logger.info(`\nFound ${baseFiles.length} potential base file(s):\n`);
+
+  const icons = { high: '✔', medium: '?', low: '○' };
+  for (const file of baseFiles) {
+    const icon = icons[file.confidence] || '?';
+    logger.info(`  ${icon} ${file.path} (confidence: ${file.confidence})`);
+    logger.dim(`    ${file.reason}`);
+  }
+
+  if (!options.interactive) {
+    logger.info('\nRecommended watch paths:');
+    for (const wp of recommendedWatchPaths || []) {
+      logger.dim(`  ${wp}`);
+    }
+    logger.info('\nRun with --interactive to accept/reject suggestions and generate config.');
+    return;
+  }
+
+  // Interactive mode: accept/reject each suggestion
+  const accepted = [];
+  for (const file of baseFiles) {
+    const { include } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'include',
+        message: `Include ${file.path}? (${file.confidence} confidence: ${file.reason})`,
+        default: file.confidence !== 'low',
+      },
+    ]);
+    if (include) accepted.push(file);
+  }
+
+  if (!accepted.length) {
+    logger.warn('No files selected. Onboard cancelled.');
+    return;
+  }
+
+  // Determine watch paths from accepted files
+  const watchPathSet = new Set();
+  for (const file of accepted) {
+    const dir = path.dirname(file.path);
+    // Use the top-level meaningful directory
+    const parts = dir.split(path.sep);
+    if (parts.length >= 2) {
+      watchPathSet.add(parts.slice(0, 2).join('/'));
+    } else {
+      watchPathSet.add(dir);
+    }
+  }
+  const watchPaths = [...watchPathSet];
+
+  logger.info(`\nWatch paths: ${watchPaths.join(', ')}`);
+
+  // Generate config
+  const { save } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'save',
+      message: 'Save as drybase.json?',
+      default: true,
+    },
+  ]);
+
+  if (!save) {
+    logger.info('Cancelled.');
+    return;
+  }
+
+  const existingConfig = config || {};
+  const newConfig = {
+    ...existingConfig,
+    baseRepo: {
+      ...existingConfig.baseRepo,
+      path: existingConfig.baseRepo?.path || '.',
+      watchPaths,
+    },
+    _metadata: {
+      onboardedAt: new Date().toISOString(),
+      llmProvider: config?.llm?.provider,
+      llmModel: config?.llm?.model,
+      filesAnalyzed: baseFiles.length,
+      suggestionsAccepted: accepted.length,
+      suggestionsRejected: baseFiles.length - accepted.length,
+    },
+  };
+
+  // Remove internal fields
+  delete newConfig._configPath;
+  delete newConfig._configDir;
+
+  const configPath = (await findConfigFile()) || path.join(resolvedPath, 'drybase.json');
+  await fs.writeFile(configPath, JSON.stringify(newConfig, null, 2) + '\n');
+  logger.success(`Updated ${configPath}`);
+  logger.dim(`  Accepted ${accepted.length}/${baseFiles.length} suggestions`);
+}
+
+async function manualOnboard(projectPath) {
+  logger.info('Scanning project structure...');
+  const tree = await scanProject(projectPath);
+  const dirs = [...new Set(tree.filter((f) => f.type === 'dir').map((f) => f.path))].sort();
+
+  if (!dirs.length) {
+    logger.warn('No directories found in project.');
+    return;
+  }
+
+  const { selectedDirs } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedDirs',
+      message: 'Select directories containing base code to sync:',
+      choices: dirs.map((d) => ({ name: d, value: d })),
+    },
+  ]);
+
+  if (!selectedDirs.length) {
+    logger.warn('No directories selected.');
+    return;
+  }
+
+  logger.info(`Selected watch paths: ${selectedDirs.join(', ')}`);
+  logger.info('Add these to your drybase.json under "baseRepo.watchPaths"');
+}

package/src/commands/rollback.js

@@ -0,0 +1,71 @@
+import inquirer from 'inquirer';
+import { loadConfig } from '../utils/config.js';
+import { loadState, saveState, getLastSync, markRolledBack } from '../utils/state.js';
+import * as git from '../core/git.js';
+import * as logger from '../utils/logger.js';
+
+export async function rollbackCommand(repoName, options) {
+  const config = await loadConfig();
+  if (!config) {
+    logger.error('No drybase.json found. Run "drybase init" to create one.');
+    process.exit(1);
+  }
+
+  const state = await loadState(config._configDir);
+  const lastSync = getLastSync(state, repoName);
+
+  if (!lastSync) {
+    logger.error(`No sync history found for "${repoName}".`);
+    process.exit(1);
+  }
+
+  if (lastSync.status === 'rolled-back') {
+    logger.warn(`Last sync for "${repoName}" was already rolled back.`);
+    process.exit(1);
+  }
+
+  if (!lastSync.commitSha) {
+    logger.error(`No commit SHA found for last sync to "${repoName}". Cannot rollback.`);
+    process.exit(1);
+  }
+
+  const targetRepo = config.targetRepos.find((r) => r.name === repoName);
+  if (!targetRepo) {
+    logger.error(`Repo "${repoName}" not found in config.`);
+    process.exit(1);
+  }
+
+  logger.info(`Last sync to ${repoName}:`);
+  logger.dim(`  Timestamp: ${lastSync.timestamp}`);
+  logger.dim(`  Commit: ${lastSync.commitSha}`);
+  logger.dim(`  Files: ${Object.keys(lastSync.files).join(', ')}`);
+
+  if (!options.yes) {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Revert commit ${lastSync.commitSha.slice(0, 8)} in ${repoName}?`,
+        default: false,
+      },
+    ]);
+    if (!confirm) {
+      logger.info('Cancelled.');
+      return;
+    }
+  }
+
+  try {
+    const revertSha = await git.revertCommit(targetRepo.localPath, lastSync.commitSha);
+    await git.pushBranch(targetRepo.localPath, targetRepo.branch || 'main');
+
+    const newState = markRolledBack(state, repoName);
+    await saveState(config._configDir, newState);
+
+    logger.success(`Rolled back sync to ${repoName} (revert commit: ${revertSha})`);
+  } catch (err) {
+    logger.error(`Rollback failed: ${err.message}`);
+    logger.debug(err.stack);
+    process.exit(1);
+  }
+}

package/src/commands/start.js

@@ -0,0 +1,51 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import * as logger from '../utils/logger.js';
+
+const DAEMON_DIR = path.join(os.homedir(), '.drybase');
+const PID_FILE = path.join(DAEMON_DIR, 'daemon.pid');
+const LOG_FILE = path.join(DAEMON_DIR, 'daemon.log');
+
+export async function startCommand() {
+  await fs.mkdir(DAEMON_DIR, { recursive: true });
+
+  // Check if already running
+  try {
+    const pid = parseInt(await fs.readFile(PID_FILE, 'utf8'), 10);
+    try {
+      process.kill(pid, 0); // signal 0 = check if alive
+      logger.warn(`Daemon already running (PID ${pid}). Use "drybase stop" first.`);
+      return;
+    } catch {
+      // Process not found — stale PID file, clean up
+      await fs.unlink(PID_FILE);
+    }
+  } catch {
+    // No PID file — good
+  }
+
+  // Spawn drybase watch as detached process
+  const binPath = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    '../../bin/drybase.js'
+  );
+
+  const logStream = await fs.open(LOG_FILE, 'a');
+
+  const child = spawn(process.execPath, [binPath, 'watch'], {
+    detached: true,
+    stdio: ['ignore', logStream.fd, logStream.fd],
+    env: { ...process.env },
+  });
+
+  child.unref();
+  await fs.writeFile(PID_FILE, String(child.pid));
+  await logStream.close();
+
+  logger.success(`Daemon started (PID ${child.pid})`);
+  logger.dim(`  Log file: ${LOG_FILE}`);
+  logger.dim(`  PID file: ${PID_FILE}`);
+}