@eltonssouza/development-utility-kit 1.0.0

package/bin/lib/sync-all.js

@@ -0,0 +1,394 @@
+'use strict';
+
+/**
+ * sync-all.js — Batch update of harness across multiple project subdirectories.
+ *
+ * Default = dry-run preview. `--apply` actually invokes the adoption pipeline
+ * via the main CLI's adoptProject() function.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { compareVersions } = require('./version-check');
+
+const HARNESS_DIR_SKIP = new Set([
+  'node_modules',
+  '.git',
+  '.idea',
+  '.vscode',
+  'dist',
+  'build',
+  'target',
+  'out',
+]);
+
+/**
+ * @typedef {{
+ *   key: 'stack'|'type'|'age'|'harness-version',
+ *   value: string|number,
+ *   op: string
+ * }} ParsedFilter
+ */
+
+/**
+ * @typedef {{
+ *   name: string,
+ *   path: string,
+ *   harnessVersion: string|null,
+ *   projectType: string|null,
+ *   primaryStack: string|null,
+ *   ageMs: number
+ * }} ProjectCandidate
+ */
+
+// ─── filter parsing ──────────────────────────────────────────────────────────
+
+/**
+ * Convert a duration string ("30d", "6m", "1y", "12h") to milliseconds.
+ * @param {string} s
+ * @returns {number|null}
+ */
+function parseDuration(s) {
+  if (!s || typeof s !== 'string') return null;
+  const m = s.match(/^(\d+)([hdmy])$/i);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  const unit = m[2].toLowerCase();
+  switch (unit) {
+    case 'h':
+      return n * 60 * 60 * 1000;
+    case 'd':
+      return n * 24 * 60 * 60 * 1000;
+    case 'm':
+      return n * 30 * 24 * 60 * 60 * 1000; // month ≈ 30d
+    case 'y':
+      return n * 365 * 24 * 60 * 60 * 1000;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Parse a single filter expression like "stack:java" or "harness-version:<0.2".
+ * @param {string} expr
+ * @returns {ParsedFilter|null}
+ */
+function parseFilterExpr(expr) {
+  if (!expr || typeof expr !== 'string') return null;
+  const idx = expr.indexOf(':');
+  if (idx === -1) return null;
+  const key = expr.slice(0, idx).trim().toLowerCase();
+  const rawValue = expr.slice(idx + 1).trim();
+  if (!rawValue) return null;
+
+  switch (key) {
+    case 'stack':
+    case 'type':
+      return { key, value: rawValue.toLowerCase(), op: '=' };
+    case 'age': {
+      const ms = parseDuration(rawValue);
+      if (ms === null) return null;
+      return { key, value: ms, op: '>=' }; // ageMs >= threshold = "older than"
+    }
+    case 'harness-version': {
+      const opMatch = rawValue.match(/^(>=|<=|>|<|=)/);
+      if (opMatch) {
+        return { key, value: rawValue, op: opMatch[1] };
+      }
+      return { key, value: '=' + rawValue, op: '=' };
+    }
+    default:
+      return null;
+  }
+}
+
+// ─── CLAUDE.md parsing ───────────────────────────────────────────────────────
+
+/**
+ * Extract a key from the `## Project Identity` block of a CLAUDE.md string.
+ * Returns the raw value (without surrounding backticks).
+ * @param {string} content
+ * @param {string} key
+ * @returns {string|null}
+ */
+function extractIdentityField(content, key) {
+  if (!content) return null;
+  const idIdx = content.indexOf('## Project Identity');
+  if (idIdx === -1) return null;
+  const nextIdx = content.indexOf('\n## ', idIdx + 1);
+  const block = nextIdx === -1 ? content.slice(idIdx) : content.slice(idIdx, nextIdx);
+
+  const re = new RegExp(
+    `[*-]\\s*\\*\\*${key.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}\\*\\*\\s*:\\s*\`?([^\`\n]+?)\`?\\s*$`,
+    'im'
+  );
+  const m = block.match(re);
+  return m ? m[1].trim() : null;
+}
+
+// ─── project discovery ──────────────────────────────────────────────────────
+
+/**
+ * Find candidate projects under dir (subdirs containing .claude/).
+ * @param {string} dir
+ * @returns {ProjectCandidate[]}
+ */
+function discoverProjects(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    if (ent.name.startsWith('.')) continue;
+    if (HARNESS_DIR_SKIP.has(ent.name)) continue;
+
+    const projectPath = path.join(dir, ent.name);
+    const claudeDir = path.join(projectPath, '.claude');
+    if (!fs.existsSync(claudeDir)) continue;
+
+    const candidate = inspectProject(projectPath);
+    if (candidate) out.push(candidate);
+  }
+
+  return out;
+}
+
+/**
+ * Build a ProjectCandidate by reading .claude/HARNESS_VERSION + CLAUDE.md.
+ * @param {string} projectPath
+ * @returns {ProjectCandidate|null}
+ */
+function inspectProject(projectPath) {
+  const claudeDir = path.join(projectPath, '.claude');
+  const versionFile = path.join(claudeDir, 'HARNESS_VERSION');
+  const claudeMdPath = path.join(projectPath, 'CLAUDE.md');
+
+  let harnessVersion = null;
+  try {
+    harnessVersion = fs.readFileSync(versionFile, 'utf8').trim() || null;
+  } catch {
+    harnessVersion = null;
+  }
+
+  let projectType = null;
+  let primaryStack = null;
+  try {
+    const content = fs.readFileSync(claudeMdPath, 'utf8');
+    projectType = extractIdentityField(content, 'Project type');
+    primaryStack = extractIdentityField(content, 'Primary stack');
+  } catch {
+    // no CLAUDE.md or unreadable
+  }
+
+  let ageMs = 0;
+  try {
+    const stat = fs.statSync(claudeDir);
+    ageMs = Date.now() - stat.mtimeMs;
+  } catch {
+    ageMs = 0;
+  }
+
+  return {
+    name: path.basename(projectPath),
+    path: projectPath,
+    harnessVersion,
+    projectType,
+    primaryStack,
+    ageMs,
+  };
+}
+
+// ─── filter application ──────────────────────────────────────────────────────
+
+/**
+ * Check whether a project matches one parsed filter.
+ * @param {ProjectCandidate} proj
+ * @param {ParsedFilter} filter
+ * @returns {boolean}
+ */
+function matchesFilter(proj, filter) {
+  if (!filter) return true;
+  switch (filter.key) {
+    case 'stack': {
+      const stack = (proj.primaryStack || '').toLowerCase();
+      return stack.includes(String(filter.value));
+    }
+    case 'type': {
+      const t = (proj.projectType || '').toLowerCase();
+      return t === String(filter.value) || t.includes(String(filter.value));
+    }
+    case 'age': {
+      return proj.ageMs >= Number(filter.value);
+    }
+    case 'harness-version': {
+      if (!proj.harnessVersion) return false;
+      const expr = String(filter.value);
+      const cmp = compareVersions(proj.harnessVersion, expr);
+      // compareVersions returns -1 when the version satisfies the constraint
+      // (or 0 for "=X" matches)
+      return cmp <= 0;
+    }
+    default:
+      return true;
+  }
+}
+
+/**
+ * Apply all filters (AND) and excludes (NOT) to a candidate list.
+ * @param {ProjectCandidate[]} candidates
+ * @param {ParsedFilter[]} filters
+ * @param {string[]} excludes
+ * @returns {ProjectCandidate[]}
+ */
+function applyFilters(candidates, filters, excludes) {
+  const excludeSet = new Set((excludes || []).map((x) => x.toLowerCase()));
+  return candidates.filter((c) => {
+    if (excludeSet.has(c.name.toLowerCase())) return false;
+    return filters.every((f) => matchesFilter(c, f));
+  });
+}
+
+// ─── humanizers ──────────────────────────────────────────────────────────────
+
+/**
+ * Convert ageMs to a short human-readable string.
+ * @param {number} ms
+ * @returns {string}
+ */
+function humanAge(ms) {
+  if (!ms || ms < 0) return 'unknown';
+  const days = Math.floor(ms / (24 * 60 * 60 * 1000));
+  if (days < 1) return '<1d';
+  if (days < 30) return `${days}d`;
+  const months = Math.floor(days / 30);
+  if (months < 12) return `${months}m`;
+  const years = Math.floor(days / 365);
+  return `${years}y`;
+}
+
+// ─── runSyncAll ──────────────────────────────────────────────────────────────
+
+/**
+ * @typedef {{ filters: string[], excludes: string[], apply: boolean,
+ *             adopt?: (opts: {cwd: string, sub: string|null, dryRun: boolean}) => void }} SyncOptions
+ */
+
+/**
+ * Run sync-all over a directory.
+ *
+ * The `adopt` option lets the CLI inject its own adoptProject implementation
+ * (avoids a circular require with bin/cli.js). When omitted, lazy-loads
+ * `../cli.js#adoptProject`.
+ *
+ * @param {string} dir
+ * @param {SyncOptions} options
+ * @returns {{ matched: ProjectCandidate[], updated: number, skipped: number, errors: number }}
+ */
+function runSyncAll(dir, options) {
+  const opts = options || {};
+  const filterStrs = opts.filters || [];
+  const excludes = opts.excludes || [];
+  const apply = !!opts.apply;
+
+  if (!dir || !fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    process.stderr.write(`Error: directory "${dir}" not found or not a directory.\n`);
+    process.exit(1);
+  }
+
+  // Parse filters
+  const parsedFilters = [];
+  for (const f of filterStrs) {
+    const parsed = parseFilterExpr(f);
+    if (!parsed) {
+      process.stderr.write(`Warning: ignoring unrecognized filter "${f}"\n`);
+      continue;
+    }
+    parsedFilters.push(parsed);
+  }
+
+  // Discover + filter
+  const candidates = discoverProjects(dir);
+  const matched = applyFilters(candidates, parsedFilters, excludes);
+
+  // Print plan
+  process.stdout.write(`\nkud sync-all — scanning ${dir}\n`);
+  process.stdout.write(`Found ${candidates.length} project(s) with .claude/\n`);
+  if (parsedFilters.length) {
+    process.stdout.write(`Filters: ${filterStrs.join(', ')}\n`);
+  }
+  if (excludes.length) {
+    process.stdout.write(`Excludes: ${excludes.join(', ')}\n`);
+  }
+  process.stdout.write(`Matched ${matched.length} project(s)${apply ? '' : ' (dry-run)'}\n\n`);
+
+  if (matched.length === 0) {
+    process.stdout.write('Nothing to do.\n');
+    return { matched: [], updated: 0, skipped: 0, errors: 0 };
+  }
+
+  // Print table
+  for (const p of matched) {
+    process.stdout.write(
+      `  ${p.name.padEnd(30)} ` +
+        `v${(p.harnessVersion || '?').padEnd(8)} ` +
+        `${(p.projectType || '?').padEnd(15)} ` +
+        `age:${humanAge(p.ageMs).padEnd(6)} ` +
+        `${(p.primaryStack || '').slice(0, 40)}\n`
+    );
+  }
+
+  if (!apply) {
+    process.stdout.write('\nDry-run only. Re-run with --apply to perform updates.\n');
+    return { matched, updated: 0, skipped: 0, errors: 0 };
+  }
+
+  // Resolve adopt function (lazy require to avoid cycles)
+  let adopt = opts.adopt;
+  if (!adopt) {
+    try {
+      const cli = require('../cli');
+      adopt = cli.adoptProject;
+    } catch (e) {
+      process.stderr.write(`Error: could not load adoptProject from bin/cli.js — ${e.message}\n`);
+      return { matched, updated: 0, skipped: 0, errors: matched.length };
+    }
+  }
+
+  // Apply per project
+  let updated = 0;
+  let errors = 0;
+  process.stdout.write('\nApplying updates...\n');
+  for (const p of matched) {
+    try {
+      adopt({ cwd: p.path, sub: null, dryRun: false });
+      process.stdout.write(`  [OK]   ${p.name}\n`);
+      updated += 1;
+    } catch (e) {
+      process.stdout.write(`  [FAIL] ${p.name} — ${e.message}\n`);
+      errors += 1;
+    }
+  }
+
+  process.stdout.write(
+    `\nSummary: updated=${updated}, errors=${errors}, skipped=${matched.length - updated - errors}\n`
+  );
+  return { matched, updated, skipped: matched.length - updated - errors, errors };
+}
+
+module.exports = {
+  runSyncAll,
+  // exported for tests
+  parseDuration,
+  parseFilterExpr,
+  extractIdentityField,
+  discoverProjects,
+  inspectProject,
+  matchesFilter,
+  applyFilters,
+  humanAge,
+};