drybase 1.0.0

package/src/utils/differ.js

@@ -0,0 +1,76 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export function computeFileHash(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash('md5');
+    const stream = createReadStream(filePath);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+export async function computeHashMap(basePath, files) {
+  const map = {};
+  for (const file of files) {
+    const fullPath = path.resolve(basePath, file);
+    try {
+      map[file] = await computeFileHash(fullPath);
+    } catch {
+      // File may have been deleted
+      map[file] = null;
+    }
+  }
+  return map;
+}
+
+export function detectDivergence(lastSyncHashes, currentHashes) {
+  const diverged = [];
+  for (const [file, currentHash] of Object.entries(currentHashes)) {
+    const lastHash = lastSyncHashes[file];
+    if (lastHash && currentHash && lastHash !== currentHash) {
+      diverged.push(file);
+    }
+  }
+  return diverged;
+}
+
+export async function diffFiles(baseDir, targetDir, relativePaths) {
+  const results = { added: [], modified: [], deleted: [], unchanged: [] };
+
+  for (const relPath of relativePaths) {
+    const baseFull = path.resolve(baseDir, relPath);
+    const targetFull = path.resolve(targetDir, relPath);
+
+    const baseExists = await fileExists(baseFull);
+    const targetExists = await fileExists(targetFull);
+
+    if (baseExists && !targetExists) {
+      results.added.push(relPath);
+    } else if (!baseExists && targetExists) {
+      results.deleted.push(relPath);
+    } else if (baseExists && targetExists) {
+      const baseHash = await computeFileHash(baseFull);
+      const targetHash = await computeFileHash(targetFull);
+      if (baseHash !== targetHash) {
+        results.modified.push(relPath);
+      } else {
+        results.unchanged.push(relPath);
+      }
+    }
+  }
+
+  return results;
+}
+
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/llm-adapter.js

@@ -0,0 +1,60 @@
+import { generateText } from 'ai';
+import * as logger from './logger.js';
+
+function getLLMProvider(llmConfig) {
+  const { provider, model, apiKey, baseURL } = llmConfig;
+
+  const providers = {
+    anthropic: async () => {
+      const { createAnthropic } = await import('@ai-sdk/anthropic');
+      return createAnthropic({ apiKey })(model);
+    },
+    openai: async () => {
+      const { createOpenAI } = await import('@ai-sdk/openai');
+      return createOpenAI({ apiKey })(model);
+    },
+    google: async () => {
+      const { createGoogleGenerativeAI } = await import('@ai-sdk/google');
+      return createGoogleGenerativeAI({ apiKey })(model);
+    },
+    mistral: async () => {
+      const { createMistral } = await import('@ai-sdk/mistral');
+      return createMistral({ apiKey })(model);
+    },
+    ollama: async () => {
+      const { createOpenAI } = await import('@ai-sdk/openai');
+      return createOpenAI({ baseURL: baseURL || 'http://localhost:11434/v1', apiKey: 'ollama' })(model);
+    },
+    'openai-compatible': async () => {
+      const { createOpenAI } = await import('@ai-sdk/openai');
+      return createOpenAI({ apiKey, baseURL })(model);
+    },
+  };
+
+  if (!providers[provider]) {
+    throw new Error(`Unsupported LLM provider: ${provider}. Supported: ${Object.keys(providers).join(', ')}`);
+  }
+
+  return providers[provider]();
+}
+
+export async function createLLMClient(llmConfig) {
+  return getLLMProvider(llmConfig);
+}
+
+export async function generateLLMText(llmConfig, prompt) {
+  const model = await getLLMProvider(llmConfig);
+  const temperature = llmConfig.options?.temperature ?? 0.3;
+  const maxTokens = llmConfig.options?.maxTokens ?? 4000;
+
+  logger.debug(`LLM request: provider=${llmConfig.provider}, model=${llmConfig.model}`);
+
+  const { text } = await generateText({
+    model,
+    messages: [{ role: 'user', content: prompt }],
+    temperature,
+    maxTokens,
+  });
+
+  return text;
+}

package/src/utils/logger.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+
+export function info(...args) {
+  console.log(chalk.blue('ℹ'), ...args);
+}
+
+export function warn(...args) {
+  console.log(chalk.yellow('⚠'), ...args);
+}
+
+export function error(...args) {
+  console.error(chalk.red('✖'), ...args);
+}
+
+export function success(...args) {
+  console.log(chalk.green('✔'), ...args);
+}
+
+export function debug(...args) {
+  if (process.env.DRYBASE_DEBUG) {
+    console.log(chalk.gray('⊙'), ...args);
+  }
+}
+
+export function dim(...args) {
+  console.log(chalk.dim(...args));
+}
+
+export function table(rows) {
+  if (!rows.length) return;
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map((k) =>
+    Math.max(k.length, ...rows.map((r) => String(r[k] ?? '').length))
+  );
+
+  const header = keys.map((k, i) => k.padEnd(widths[i])).join('  ');
+  const separator = widths.map((w) => '─'.repeat(w)).join('──');
+
+  console.log(chalk.bold(header));
+  console.log(chalk.dim(separator));
+  for (const row of rows) {
+    const line = keys.map((k, i) => String(row[k] ?? '').padEnd(widths[i])).join('  ');
+    console.log(line);
+  }
+}

package/src/utils/state.js

@@ -0,0 +1,79 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+const STATE_FILE = '.drybase-state.json';
+
+function emptyState() {
+  return { lastSync: {}, syncHistory: [] };
+}
+
+export async function loadState(configDir) {
+  const filePath = path.join(configDir, STATE_FILE);
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return emptyState();
+  }
+}
+
+export async function saveState(configDir, state) {
+  const filePath = path.join(configDir, STATE_FILE);
+  await fs.writeFile(filePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+export function getLastSync(state, repoName) {
+  return state.lastSync?.[repoName] || null;
+}
+
+export function recordSync(state, { repo, files, commitSha, status }) {
+  const timestamp = new Date().toISOString();
+  const id = `sync-${crypto.randomUUID().slice(0, 8)}`;
+
+  const newLastSync = {
+    ...state.lastSync,
+    [repo]: { timestamp, files, commitSha, status },
+  };
+
+  const entry = {
+    id,
+    timestamp,
+    repo,
+    files: Object.keys(files),
+    commitSha,
+    status,
+  };
+
+  const newHistory = [entry, ...state.syncHistory];
+
+  return { lastSync: newLastSync, syncHistory: newHistory };
+}
+
+export function markRolledBack(state, repo) {
+  // Update the most recent history entry for this repo
+  const newHistory = state.syncHistory.map((entry) => {
+    if (entry.repo === repo && entry.status === 'success') {
+      // Only mark the first (most recent) matching entry
+      return { ...entry, status: 'rolled-back' };
+    }
+    return entry;
+  });
+
+  // Find the first matching entry and only mark that one
+  let found = false;
+  const rolledHistory = state.syncHistory.map((entry) => {
+    if (!found && entry.repo === repo && entry.status === 'success') {
+      found = true;
+      return { ...entry, status: 'rolled-back' };
+    }
+    return entry;
+  });
+
+  const newLastSync = { ...state.lastSync };
+  if (newLastSync[repo]) {
+    newLastSync[repo] = { ...newLastSync[repo], status: 'rolled-back' };
+  }
+
+  return { lastSync: newLastSync, syncHistory: rolledHistory };
+}

package/src/utils/test-runner.js

@@ -0,0 +1,58 @@
+import { spawn } from 'node:child_process';
+import * as logger from './logger.js';
+
+const DEFAULT_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+
+export function runTests(command, cwd, { timeout = DEFAULT_TIMEOUT } = {}) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    logger.info(`Running tests: ${command}`);
+
+    const [cmd, ...args] = command.split(' ');
+    const child = spawn(cmd, args, {
+      cwd,
+      shell: true,
+      stdio: 'pipe',
+      env: { ...process.env },
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      const duration = Date.now() - start;
+      logger.warn(`Tests timed out after ${Math.round(duration / 1000)}s`);
+      resolve({ passed: false, output: stdout + stderr + '\n[TIMEOUT]', duration });
+    }, timeout);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      const duration = Date.now() - start;
+      const passed = code === 0;
+
+      if (passed) {
+        logger.success(`Tests passed in ${Math.round(duration / 1000)}s`);
+      } else {
+        logger.warn(`Tests failed (exit code ${code})`);
+      }
+
+      resolve({ passed, output: stdout + stderr, duration });
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      const duration = Date.now() - start;
+      logger.error(`Test execution error: ${err.message}`);
+      resolve({ passed: false, output: err.message, duration });
+    });
+  });
+}