drybase 1.0.0

package/src/commands/status.js

@@ -0,0 +1,33 @@
+import { loadConfig } from '../utils/config.js';
+import { loadState, getLastSync } from '../utils/state.js';
+import * as logger from '../utils/logger.js';
+
+export async function statusCommand() {
+  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 rows = [];
+
+  for (const repo of config.targetRepos) {
+    const last = getLastSync(state, repo.name);
+    rows.push({
+      Repo: repo.name,
+      Mode: repo.syncMode || 'pr-always',
+      'Last Sync': last ? new Date(last.timestamp).toLocaleString() : 'Never',
+      Files: last ? Object.keys(last.files).length : 0,
+      Status: last?.status || 'pending',
+    });
+  }
+
+  if (!rows.length) {
+    logger.warn('No target repos configured.');
+    return;
+  }
+
+  logger.info('Sync Status\n');
+  logger.table(rows);
+}

package/src/commands/stop.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import * as logger from '../utils/logger.js';
+
+const PID_FILE = path.join(os.homedir(), '.drybase', 'daemon.pid');
+
+export async function stopCommand() {
+  let pid;
+  try {
+    pid = parseInt(await fs.readFile(PID_FILE, 'utf8'), 10);
+  } catch {
+    logger.warn('No daemon running (PID file not found).');
+    return;
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    logger.success(`Daemon stopped (PID ${pid})`);
+  } catch (err) {
+    if (err.code === 'ESRCH') {
+      logger.warn(`Process ${pid} not found. Cleaning up stale PID file.`);
+    } else {
+      logger.error(`Failed to stop daemon: ${err.message}`);
+    }
+  }
+
+  try {
+    await fs.unlink(PID_FILE);
+  } catch {
+    // Already cleaned up
+  }
+}

package/src/commands/sync.js

@@ -0,0 +1,35 @@
+import { loadConfig, validateConfig } from '../utils/config.js';
+import { syncAll } from '../core/syncer.js';
+import * as logger from '../utils/logger.js';
+
+export async function syncCommand(options) {
+  const config = await loadConfig();
+  if (!config) {
+    logger.error('No drybase.json found. Run "drybase init" to create one.');
+    process.exit(1);
+  }
+
+  const errors = validateConfig(config);
+  if (errors) {
+    logger.error('Invalid configuration:');
+    for (const e of errors) logger.error(`  - ${e}`);
+    process.exit(1);
+  }
+
+  if (options.dryRun) {
+    logger.info('[DRY RUN] Previewing sync...\n');
+  }
+
+  const results = await syncAll(config, {
+    repo: options.repo,
+    dryRun: options.dryRun,
+    force: options.force,
+  });
+
+  // Summary
+  logger.info('\nSync Summary:');
+  for (const r of results) {
+    const icon = r.status === 'success' ? '  ✔' : r.status === 'failed' ? '  ✖' : '  ℹ';
+    logger.info(`${icon} ${r.repo}: ${r.status}`);
+  }
+}

package/src/commands/validate.js

@@ -0,0 +1,34 @@
+import { loadConfig, validateConfig, findConfigFile } from '../utils/config.js';
+import * as logger from '../utils/logger.js';
+
+export async function validateCommand() {
+  const configPath = await findConfigFile();
+  if (!configPath) {
+    logger.error('No drybase.json found. Run "drybase init" to create one.');
+    process.exit(1);
+  }
+
+  logger.info(`Validating ${configPath}`);
+
+  let config;
+  try {
+    config = await loadConfig(configPath);
+  } catch (err) {
+    logger.error(`Failed to load config: ${err.message}`);
+    process.exit(1);
+  }
+
+  const errors = validateConfig(config);
+  if (errors) {
+    logger.error('Configuration errors:');
+    for (const err of errors) {
+      logger.error(`  - ${err}`);
+    }
+    process.exit(1);
+  }
+
+  logger.success('Configuration is valid');
+  logger.dim(`  Base repo: ${config.baseRepo.path}`);
+  logger.dim(`  Watch paths: ${config.baseRepo.watchPaths.join(', ')}`);
+  logger.dim(`  Target repos: ${config.targetRepos.map((r) => r.name).join(', ')}`);
+}

package/src/commands/watch.js

@@ -0,0 +1,33 @@
+import { loadConfig, validateConfig } from '../utils/config.js';
+import { createWatcher } from '../core/watcher.js';
+import * as logger from '../utils/logger.js';
+
+export async function watchCommand() {
+  const config = await loadConfig();
+  if (!config) {
+    logger.error('No drybase.json found. Run "drybase init" to create one.');
+    process.exit(1);
+  }
+
+  const errors = validateConfig(config);
+  if (errors) {
+    logger.error('Invalid configuration:');
+    for (const e of errors) logger.error(`  - ${e}`);
+    process.exit(1);
+  }
+
+  logger.info('Starting file watcher...');
+
+  const watcher = createWatcher(config);
+
+  // Graceful shutdown
+  const cleanup = async () => {
+    logger.info('\nStopping watcher...');
+    await watcher.close();
+    logger.success('Watcher stopped.');
+    process.exit(0);
+  };
+
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+}

package/src/core/analyzer.js

@@ -0,0 +1,157 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { generateLLMText } from '../utils/llm-adapter.js';
+import * as logger from '../utils/logger.js';
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', 'vendor', 'dist', 'build', '.next',
+  '__pycache__', '.cache', 'coverage', '.nyc_output',
+]);
+
+const IGNORE_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.woff', '.woff2',
+  '.ttf', '.eot', '.mp4', '.mp3', '.zip', '.tar', '.gz', '.lock',
+]);
+
+const MAX_SAMPLE_LINES = 10;
+const MAX_FILES_TO_SAMPLE = 50;
+
+export async function scanProject(projectPath) {
+  const tree = [];
+  await walkDir(projectPath, projectPath, tree);
+  return tree;
+}
+
+async function walkDir(dir, rootDir, tree) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || IGNORE_DIRS.has(entry.name)) continue;
+
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.relative(rootDir, fullPath);
+
+    if (entry.isDirectory()) {
+      tree.push({ path: relativePath, type: 'dir' });
+      await walkDir(fullPath, rootDir, tree);
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (IGNORE_EXTENSIONS.has(ext)) continue;
+
+      try {
+        const stat = await fs.stat(fullPath);
+        tree.push({
+          path: relativePath,
+          type: 'file',
+          size: stat.size,
+          ext,
+        });
+      } catch {
+        // Skip inaccessible files
+      }
+    }
+  }
+}
+
+export async function sampleFiles(projectPath, fileTree) {
+  const files = fileTree.filter((f) => f.type === 'file' && f.size < 50000);
+  const sampled = files.slice(0, MAX_FILES_TO_SAMPLE);
+  const samples = [];
+
+  for (const file of sampled) {
+    try {
+      const content = await fs.readFile(path.join(projectPath, file.path), 'utf8');
+      const lines = content.split('\n');
+      const sample = lines.slice(0, MAX_SAMPLE_LINES).join('\n');
+      samples.push({ path: file.path, sample, totalLines: lines.length });
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  return samples;
+}
+
+export function buildAnalysisPrompt(fileTree, samples) {
+  const treeStr = fileTree.map((f) => {
+    if (f.type === 'dir') return `📁 ${f.path}/`;
+    return `   ${f.path} (${f.size}b)`;
+  }).join('\n');
+
+  const samplesStr = samples.map((s) =>
+    `--- ${s.path} (${s.totalLines} lines) ---\n${s.sample}\n`
+  ).join('\n');
+
+  return `Analyze this project structure and identify files that are likely "base code" that would be shared across multiple similar projects.
+
+Base code typically includes:
+- Utility functions and helpers
+- Configuration templates
+- Shared UI components
+- API clients and wrappers
+- Common middleware
+- Validation schemas
+- Type definitions
+- Database helpers
+- Authentication utilities
+
+Project structure:
+${treeStr}
+
+Sample file contents:
+${samplesStr}
+
+Respond with JSON only (no markdown, no explanation):
+{
+  "baseFiles": [
+    {
+      "path": "src/utils/logger.js",
+      "confidence": "high|medium|low",
+      "reason": "Generic logging utility with no project-specific code",
+      "category": "utility"
+    }
+  ],
+  "recommendedWatchPaths": ["src/utils", "src/middleware"],
+  "recommendedSyncPaths": {
+    "utils": "src/utils",
+    "config": "config/base"
+  }
+}`;
+}
+
+export async function analyzeProject(projectPath, llmConfig) {
+  logger.info('Scanning project...');
+  const tree = await scanProject(projectPath);
+  logger.info(`Found ${tree.filter((f) => f.type === 'file').length} files`);
+
+  logger.info('Sampling file contents...');
+  const samples = await sampleFiles(projectPath, tree);
+
+  logger.info('Analyzing with LLM...');
+  const prompt = buildAnalysisPrompt(tree, samples);
+
+  const text = await generateLLMText(llmConfig, prompt);
+
+  // Parse JSON, with fallback for markdown-wrapped responses
+  let analysis;
+  try {
+    analysis = JSON.parse(text);
+  } catch {
+    // Try extracting JSON from markdown code block
+    const match = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (match) {
+      analysis = JSON.parse(match[1].trim());
+    } else {
+      logger.error('Failed to parse LLM response as JSON');
+      logger.debug(text);
+      return null;
+    }
+  }
+
+  return analysis;
+}

package/src/core/git.js

@@ -0,0 +1,81 @@
+import simpleGit from 'simple-git';
+import * as logger from '../utils/logger.js';
+
+export function getGit(repoPath) {
+  return simpleGit(repoPath);
+}
+
+export async function isClean(repoPath) {
+  const git = getGit(repoPath);
+  const status = await git.status();
+  return status.isClean();
+}
+
+export async function createBranch(repoPath, branchName, baseBranch) {
+  const git = getGit(repoPath);
+  await git.checkout(baseBranch);
+  await git.pull('origin', baseBranch);
+  await git.checkoutLocalBranch(branchName);
+  logger.debug(`Created branch ${branchName} from ${baseBranch}`);
+  return branchName;
+}
+
+export async function checkoutBranch(repoPath, branchName) {
+  const git = getGit(repoPath);
+  await git.checkout(branchName);
+}
+
+export async function commitFiles(repoPath, files, message) {
+  const git = getGit(repoPath);
+  await git.add(files);
+  const result = await git.commit(message);
+  logger.debug(`Committed ${files.length} files: ${result.commit}`);
+  return result.commit;
+}
+
+export async function pushBranch(repoPath, branchName) {
+  const git = getGit(repoPath);
+  await git.push('origin', branchName, ['--set-upstream']);
+  logger.debug(`Pushed branch ${branchName}`);
+}
+
+export async function revertCommit(repoPath, commitSha) {
+  const git = getGit(repoPath);
+  await git.revert(commitSha, ['--no-edit']);
+  const log = await git.log({ n: 1 });
+  const revertSha = log.latest.hash;
+  logger.debug(`Reverted ${commitSha}, new commit: ${revertSha}`);
+  return revertSha;
+}
+
+export async function stashAndRestore(repoPath, fn) {
+  const git = getGit(repoPath);
+  const status = await git.status();
+  const needsStash = !status.isClean();
+
+  if (needsStash) {
+    await git.stash(['push', '-m', 'drybase-temp-stash']);
+    logger.debug('Stashed local changes');
+  }
+
+  try {
+    return await fn();
+  } finally {
+    if (needsStash) {
+      await git.stash(['pop']);
+      logger.debug('Restored stashed changes');
+    }
+  }
+}
+
+export async function getCurrentBranch(repoPath) {
+  const git = getGit(repoPath);
+  const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+  return branch.trim();
+}
+
+export async function getLatestCommitSha(repoPath) {
+  const git = getGit(repoPath);
+  const log = await git.log({ n: 1 });
+  return log.latest?.hash || null;
+}

package/src/core/github.js

@@ -0,0 +1,91 @@
+import { Octokit } from '@octokit/rest';
+import * as logger from '../utils/logger.js';
+
+let _octokit = null;
+
+export function initOctokit(token) {
+  _octokit = new Octokit({ auth: token });
+  return _octokit;
+}
+
+function getOctokit() {
+  if (!_octokit) throw new Error('Octokit not initialized. Call initOctokit(token) first.');
+  return _octokit;
+}
+
+export function parseRepoName(name) {
+  const parts = name.split('/');
+  if (parts.length !== 2) throw new Error(`Invalid repo name "${name}". Expected "owner/repo" format.`);
+  return { owner: parts[0], repo: parts[1] };
+}
+
+async function withRetry(fn, { maxRetries = 3, baseDelay = 1000 } = {}) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      // Rate limit handling
+      if (err.status === 403 && err.response?.headers?.['x-ratelimit-remaining'] === '0') {
+        const resetTime = parseInt(err.response.headers['x-ratelimit-reset'], 10) * 1000;
+        const waitMs = Math.max(resetTime - Date.now(), 1000);
+        logger.warn(`Rate limited. Waiting ${Math.ceil(waitMs / 1000)}s...`);
+        await sleep(waitMs);
+        continue;
+      }
+
+      if (attempt < maxRetries && (err.status >= 500 || err.status === 429)) {
+        const delay = baseDelay * Math.pow(2, attempt);
+        logger.debug(`Retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
+        await sleep(delay);
+        continue;
+      }
+
+      throw err;
+    }
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function createPullRequest({ repoName, title, body, head, base, labels }) {
+  const { owner, repo } = parseRepoName(repoName);
+  const octokit = getOctokit();
+
+  const { data: pr } = await withRetry(() =>
+    octokit.pulls.create({ owner, repo, title, body, head, base })
+  );
+
+  if (labels?.length) {
+    await withRetry(() =>
+      octokit.issues.addLabels({ owner, repo, issue_number: pr.number, labels })
+    );
+  }
+
+  logger.debug(`Created PR #${pr.number}: ${title}`);
+  return pr;
+}
+
+export async function mergePullRequest({ repoName, pullNumber, mergeMethod = 'squash' }) {
+  const { owner, repo } = parseRepoName(repoName);
+  const octokit = getOctokit();
+
+  const { data } = await withRetry(() =>
+    octokit.pulls.merge({ owner, repo, pull_number: pullNumber, merge_method: mergeMethod })
+  );
+
+  logger.debug(`Merged PR #${pullNumber}`);
+  return data;
+}
+
+export async function addPRComment({ repoName, pullNumber, body }) {
+  const { owner, repo } = parseRepoName(repoName);
+  const octokit = getOctokit();
+
+  const { data } = await withRetry(() =>
+    octokit.issues.createComment({ owner, repo, issue_number: pullNumber, body })
+  );
+
+  return data;
+}