dw-kit 1.0.0

package/src/commands/upgrade.mjs

@@ -0,0 +1,262 @@
+import { existsSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { header, ok, warn, err, info, log, dry } from '../lib/ui.mjs';
+import { loadConfig, writeConfig, getToolkitVersions } from '../lib/config.mjs';
+import { diffDirs, copyDir, copyFile } from '../lib/copy.mjs';
+
+const TOOLKIT_ROOT = resolve(fileURLToPath(import.meta.url), '..', '..', '..');
+
+export async function upgradeCommand(opts) {
+  const projectDir = process.cwd();
+  const configPath = join(projectDir, '.dw', 'config', 'dw.config.yml');
+
+  if (!existsSync(configPath)) {
+    err('No .dw/config/dw.config.yml found. Run `dw init` first.');
+    process.exit(1);
+  }
+
+  const projectConfig = loadConfig(configPath);
+  const projectVersions = getToolkitVersions(projectConfig);
+
+  const toolkitPkg = JSON.parse(readFileSync(join(TOOLKIT_ROOT, 'package.json'), 'utf-8'));
+  const toolkitConfig = loadConfig(join(TOOLKIT_ROOT, '.dw', 'config', 'dw.config.yml'));
+  const toolkitVersions = getToolkitVersions(toolkitConfig);
+
+  header('dw-kit Upgrade');
+  log(`Installed (package) : v${toolkitPkg.version}`);
+  log(`Project core        : ${projectVersions.core}`);
+  log(`Toolkit core        : ${toolkitVersions.core}`);
+  if (opts.dryRun) log('Mode: DRY RUN (no changes)');
+  console.log();
+
+  if (opts.check) {
+    if (projectVersions.core === toolkitVersions.core) {
+      ok('Already up to date.');
+    } else {
+      log(`Update available: ${projectVersions.core} → ${toolkitVersions.core}`);
+    }
+    return;
+  }
+
+  const layer = opts.layer || 'all';
+  let totalChanges = 0;
+
+  if (layer === 'all' || layer === 'core') {
+    totalChanges += upgradeCore(projectDir, opts);
+  }
+
+  if (layer === 'all' || layer === 'platform') {
+    totalChanges += upgradePlatform(projectDir, opts);
+  }
+
+  if (layer === 'all' || layer === 'capability') {
+    totalChanges += upgradeCapability(projectDir, opts);
+  }
+
+  upgradeScripts(projectDir, opts);
+  upgradeConfigSchema(projectDir, opts);
+
+  if (!opts.dryRun && totalChanges > 0) {
+    updateVersionTracking(configPath, projectConfig, toolkitVersions);
+  }
+
+  console.log();
+  header(opts.dryRun ? 'DRY RUN complete — no changes made' : `Upgrade complete (${totalChanges} files updated)`);
+  if (opts.dryRun) log('Run without --dry-run to apply.');
+  console.log();
+}
+
+function upgradeCore(projectDir, opts) {
+  info('Layer 0: Methodology Core (.dw/core/)');
+  const src = join(TOOLKIT_ROOT, '.dw', 'core');
+  const dst = join(projectDir, '.dw', 'core');
+
+  const diff = diffDirs(src, dst);
+  reportDiff(diff);
+
+  if (diff.added.length === 0 && diff.modified.length === 0) {
+    ok('Core files are up to date');
+    return 0;
+  }
+
+  const filesToUpdate = [...diff.added, ...diff.modified];
+  for (const file of filesToUpdate) {
+    if (opts.dryRun) {
+      dry(`${diff.added.includes(file) ? 'add' : 'update'} .dw/core/${file}`);
+    } else {
+      copyFile(join(src, file), join(dst, file));
+      ok(`.dw/core/${file}`);
+    }
+  }
+  return filesToUpdate.length;
+}
+
+function upgradePlatform(projectDir, opts) {
+  info('Layer 1: Platform Files (.claude/)');
+  const src = join(TOOLKIT_ROOT, '.claude');
+  const dst = join(projectDir, '.claude');
+
+  if (!existsSync(dst)) {
+    warn('.claude/ not found — skipping platform upgrade (run dw init first)');
+    return 0;
+  }
+
+  const overridesDir = join(projectDir, '.dw', 'adapters', 'claude-cli', 'overrides');
+  const diff = diffDirs(src, dst);
+  reportDiff(diff);
+
+  if (diff.added.length === 0 && diff.modified.length === 0) {
+    ok('Platform files are up to date');
+    return 0;
+  }
+
+  let count = 0;
+  const filesToUpdate = [...diff.added, ...diff.modified];
+  for (const file of filesToUpdate) {
+    const overridePath = join(overridesDir, file);
+    if (existsSync(overridePath)) {
+      warn(`${file}: override exists → keeping your version`);
+      continue;
+    }
+
+    if (opts.dryRun) {
+      dry(`${diff.added.includes(file) ? 'add' : 'update'} .claude/${file}`);
+    } else {
+      copyFile(join(src, file), join(dst, file));
+      ok(`.claude/${file}`);
+    }
+    count++;
+  }
+
+  copyExtensions(projectDir, opts);
+  mergeSettingsJson(projectDir, opts);
+
+  return count;
+}
+
+function copyExtensions(projectDir, opts) {
+  const extDir = join(projectDir, '.dw', 'adapters', 'claude-cli', 'extensions');
+  const skillsDir = join(projectDir, '.claude', 'skills');
+
+  if (!existsSync(extDir)) return;
+
+  let count = 0;
+  try {
+    const entries = readdirSync(extDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name === '.gitkeep') continue;
+      const src = join(extDir, entry.name);
+      const dst = join(skillsDir, entry.name);
+      if (opts.dryRun) {
+        dry(`install extension: ${entry.name}`);
+      } else {
+        copyDir(src, dst, { overwrite: true });
+        ok(`Extension '${entry.name}' installed`);
+      }
+      count++;
+    }
+  } catch { /* empty extensions dir */ }
+  if (count === 0) log('No extensions found');
+}
+
+function mergeSettingsJson(projectDir, opts) {
+  const toolkitSettings = join(TOOLKIT_ROOT, '.claude', 'settings.json');
+  const projectSettings = join(projectDir, '.claude', 'settings.json');
+
+  if (!existsSync(toolkitSettings) || !existsSync(projectSettings)) return;
+
+  if (opts.dryRun) {
+    dry('merge .claude/settings.json');
+    return;
+  }
+
+  try {
+    const template = JSON.parse(readFileSync(toolkitSettings, 'utf-8'));
+    const current = JSON.parse(readFileSync(projectSettings, 'utf-8'));
+    const merged = deepMerge(template, current);
+    writeFileSync(projectSettings, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+    ok('settings.json: merged');
+  } catch (e) {
+    warn(`settings.json merge failed: ${e.message}`);
+  }
+}
+
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const [key, val] of Object.entries(override)) {
+    if (key in result && typeof result[key] === 'object' && !Array.isArray(result[key]) && typeof val === 'object' && !Array.isArray(val)) {
+      result[key] = deepMerge(result[key], val);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+function upgradeCapability(projectDir, opts) {
+  info('Layer 2: Capability Config');
+  ok('Capability layer is config-driven — no file changes needed');
+  log('Review claude: section in .dw/config/dw.config.yml for new options');
+  return 0;
+}
+
+function upgradeScripts(projectDir, opts) {
+  info('Scripts');
+  const src = join(TOOLKIT_ROOT, 'scripts');
+  const dst = join(projectDir, 'scripts');
+
+  if (!existsSync(src)) return;
+
+  const diff = diffDirs(src, dst);
+  if (diff.added.length === 0 && diff.modified.length === 0) {
+    ok('Scripts are up to date');
+    return;
+  }
+
+  for (const file of [...diff.added, ...diff.modified]) {
+    if (opts.dryRun) {
+      dry(`update scripts/${file}`);
+    } else {
+      copyFile(join(src, file), join(dst, file));
+      ok(`scripts/${file}`);
+    }
+  }
+}
+
+function upgradeConfigSchema(projectDir, opts) {
+  const src = join(TOOLKIT_ROOT, '.dw', 'config', 'config.schema.json');
+  const dst = join(projectDir, '.dw', 'config', 'config.schema.json');
+
+  if (!existsSync(src)) return;
+  if (existsSync(dst)) {
+    const srcContent = readFileSync(src, 'utf-8');
+    const dstContent = readFileSync(dst, 'utf-8');
+    if (srcContent === dstContent) return;
+  }
+
+    if (opts.dryRun) {
+      dry('update .dw/config/config.schema.json');
+    } else {
+      copyFile(src, dst);
+      ok('.dw/config/config.schema.json updated');
+    }
+}
+
+function updateVersionTracking(configPath, config, toolkitVersions) {
+  const today = new Date().toISOString().split('T')[0];
+  if (!config._toolkit) config._toolkit = {};
+  config._toolkit.core_version = toolkitVersions.core;
+  config._toolkit.platform_version = toolkitVersions.platform;
+  config._toolkit.capability_version = toolkitVersions.capability;
+  config._toolkit.last_upgrade = today;
+
+  writeConfig(configPath, config);
+  ok(`Version tracking updated: core=${toolkitVersions.core}, date=${today}`);
+}
+
+function reportDiff(diff) {
+  if (diff.added.length > 0) log(`  New files: ${diff.added.length}`);
+  if (diff.modified.length > 0) log(`  Modified:  ${diff.modified.length}`);
+  if (diff.unchanged.length > 0) log(`  Unchanged: ${diff.unchanged.length}`);
+}

package/src/commands/validate.mjs

@@ -0,0 +1,102 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Ajv from 'ajv';
+import { header, ok, warn, err, info, log } from '../lib/ui.mjs';
+import { loadConfig, loadSchema } from '../lib/config.mjs';
+
+const TOOLKIT_ROOT = resolve(fileURLToPath(import.meta.url), '..', '..', '..');
+
+export async function validateCommand(opts) {
+  const configPath = resolve(opts.file);
+
+  header('dw-kit Config Validation');
+
+  if (!existsSync(configPath)) {
+    err(`Config file not found: ${configPath}`);
+    log('Run `dw init` to create a config file.');
+    process.exit(1);
+  }
+
+  info(`Loading ${opts.file}`);
+  const config = loadConfig(configPath);
+  if (!config) {
+    err('Failed to parse YAML config.');
+    process.exit(1);
+  }
+  ok('YAML syntax valid');
+
+  info('Validating against schema');
+  const schemaPath = resolve('.dw', 'config', 'config.schema.json');
+  const fallbackSchemaPath = join(TOOLKIT_ROOT, '.dw', 'config', 'config.schema.json');
+  let schema = loadSchema(schemaPath) || loadSchema(fallbackSchemaPath);
+
+  if (!schema) {
+    warn('Schema file not found — skipping schema validation');
+    warn('Expected at: .dw/config/config.schema.json');
+    return;
+  }
+
+  const ajv = new Ajv({ allErrors: true, strict: false });
+  const validate = ajv.compile(schema);
+  const valid = validate(config);
+
+  if (valid) {
+    ok('Schema validation passed');
+  } else {
+    err('Schema validation failed:');
+    for (const error of validate.errors) {
+      const path = error.instancePath || '(root)';
+      log(`  ${path}: ${error.message}`);
+      if (error.params?.allowedValues) {
+        log(`    Allowed: ${error.params.allowedValues.join(', ')}`);
+      }
+      if (error.params?.additionalProperty) {
+        log(`    Unknown key: ${error.params.additionalProperty}`);
+      }
+    }
+    process.exit(1);
+  }
+
+  info('Semantic checks');
+  runSemanticChecks(config);
+
+  console.log();
+  ok('Config is valid.');
+  console.log();
+}
+
+function runSemanticChecks(config) {
+  const warnings = [];
+
+  if (!config.project?.name || config.project.name === 'my-project') {
+    warnings.push('project.name is still "my-project" — consider updating');
+  }
+
+  if (config.quality?.block_on_fail && !config.quality?.test_command && !config.quality?.lint_command) {
+    warnings.push('quality.block_on_fail is true but no test_command or lint_command configured');
+  }
+
+  if (config.tracking?.estimation && config.workflow?.default_depth === 'quick') {
+    warnings.push('tracking.estimation is enabled but depth is "quick" — estimation may add unnecessary overhead');
+  }
+
+  const roles = config.team?.roles || [];
+  if (roles.includes('pm') && !config.tracking?.log_work) {
+    warnings.push('PM role enabled but tracking.log_work is false — PM dashboard needs work logs');
+  }
+
+  if (roles.includes('qc') && !config.quality?.test_command) {
+    warnings.push('QC role enabled but no quality.test_command — QC workflow benefits from tests');
+  }
+
+  if (config.claude?.worktree_execution && config.workflow?.default_depth === 'quick') {
+    warnings.push('claude.worktree_execution is true with "quick" depth — worktree is typically for thorough workflows');
+  }
+
+  if (warnings.length === 0) {
+    ok('No semantic issues found');
+  } else {
+    for (const w of warnings) warn(w);
+  }
+}

package/src/lib/config.mjs

@@ -0,0 +1,75 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import yaml from 'js-yaml';
+
+export function loadConfig(configPath) {
+  if (!existsSync(configPath)) return null;
+  const content = readFileSync(configPath, 'utf-8');
+  return yaml.load(content);
+}
+
+export function writeConfig(configPath, data) {
+  const content = yaml.dump(data, {
+    indent: 2,
+    lineWidth: -1,
+    quotingType: '"',
+    forceQuotes: false,
+    noRefs: true,
+  });
+  writeFileSync(configPath, content, 'utf-8');
+}
+
+export function loadSchema(schemaPath) {
+  if (!existsSync(schemaPath)) return null;
+  return JSON.parse(readFileSync(schemaPath, 'utf-8'));
+}
+
+export function buildConfig({ projectName, language, depth, roles }) {
+  const today = new Date().toISOString().split('T')[0];
+  return {
+    project: {
+      name: projectName,
+      language: language,
+    },
+    workflow: {
+      default_depth: depth,
+    },
+    team: {
+      roles: roles,
+    },
+    quality: {
+      test_command: '',
+      lint_command: '',
+      block_on_fail: false,
+    },
+    tracking: {
+      estimation: depth !== 'quick',
+      log_work: depth === 'thorough',
+      estimation_unit: 'hours',
+    },
+    paths: {
+      tasks: '.dw/tasks',
+      docs: '.dw/docs',
+    },
+    claude: {
+      models: { plan: '', execute: '', review: '' },
+      structured_output: depth !== 'quick',
+      worktree_execution: false,
+      mcp: [],
+    },
+    _toolkit: {
+      core_version: '1.0',
+      platform_version: '1.0',
+      capability_version: '1.0',
+      installed: today,
+      last_upgrade: today,
+    },
+  };
+}
+
+export function getToolkitVersions(config) {
+  return {
+    core: config?._toolkit?.core_version || 'unknown',
+    platform: config?._toolkit?.platform_version || 'unknown',
+    capability: config?._toolkit?.capability_version || 'unknown',
+  };
+}

package/src/lib/copy.mjs

@@ -0,0 +1,110 @@
+import {
+  existsSync, mkdirSync, copyFileSync, readdirSync, readFileSync,
+} from 'node:fs';
+import { join, dirname } from 'node:path';
+
+export function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+export function copyFile(src, dst, { dryRun = false } = {}) {
+  if (dryRun) return { action: 'copy', src, dst, applied: false };
+  ensureDir(dirname(dst));
+  copyFileSync(src, dst);
+  return { action: 'copy', src, dst, applied: true };
+}
+
+export function copyDir(srcDir, dstDir, { dryRun = false, overwrite = false } = {}) {
+  const results = [];
+  if (!existsSync(srcDir)) return results;
+
+  const entries = readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const dstPath = join(dstDir, entry.name);
+
+    if (entry.isDirectory()) {
+      results.push(...copyDir(srcPath, dstPath, { dryRun, overwrite }));
+    } else if (entry.isFile()) {
+      if (!overwrite && existsSync(dstPath)) {
+        results.push({ action: 'skip', src: srcPath, dst: dstPath, reason: 'exists' });
+        continue;
+      }
+      results.push(copyFile(srcPath, dstPath, { dryRun }));
+    }
+  }
+  return results;
+}
+
+/**
+ * Copy files from srcDir to dstDir, respecting an overrides directory.
+ * Files present in overridesDir take precedence over srcDir.
+ */
+export function copyWithOverrides(srcDir, dstDir, overridesDir, { dryRun = false } = {}) {
+  const results = [];
+  if (!existsSync(srcDir)) return results;
+
+  const entries = readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const dstPath = join(dstDir, entry.name);
+    const overridePath = overridesDir ? join(overridesDir, entry.name) : null;
+
+    if (entry.isDirectory()) {
+      const subOverride = overridePath && existsSync(overridePath) ? overridePath : null;
+      results.push(...copyWithOverrides(srcPath, dstPath, subOverride, { dryRun }));
+    } else if (entry.isFile()) {
+      if (overridePath && existsSync(overridePath)) {
+        results.push({
+          action: 'override',
+          src: overridePath,
+          dst: dstPath,
+          ...(dryRun ? { applied: false } : (() => { ensureDir(dirname(dstPath)); copyFileSync(overridePath, dstPath); return { applied: true }; })()),
+        });
+      } else {
+        results.push(copyFile(srcPath, dstPath, { dryRun }));
+      }
+    }
+  }
+  return results;
+}
+
+/**
+ * Compute file differences between two directories.
+ * Returns { added, modified, unchanged } arrays of relative paths.
+ */
+export function diffDirs(sourceDir, targetDir) {
+  const added = [];
+  const modified = [];
+  const unchanged = [];
+
+  if (!existsSync(sourceDir)) return { added, modified, unchanged };
+
+  function walk(dir, base) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = join(dir, entry.name);
+      const relPath = base ? join(base, entry.name) : entry.name;
+
+      if (entry.isDirectory()) {
+        walk(srcPath, relPath);
+      } else if (entry.isFile()) {
+        const targetPath = join(targetDir, relPath);
+        if (!existsSync(targetPath)) {
+          added.push(relPath);
+        } else {
+          const srcContent = readFileSync(srcPath);
+          const tgtContent = readFileSync(targetPath);
+          if (srcContent.equals(tgtContent)) {
+            unchanged.push(relPath);
+          } else {
+            modified.push(relPath);
+          }
+        }
+      }
+    }
+  }
+
+  walk(sourceDir, '');
+  return { added, modified, unchanged };
+}

package/src/lib/platform.mjs

@@ -0,0 +1,39 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+/**
+ * Detect which AI development platform is available.
+ * Returns: 'claude-cli' | 'cursor' | 'generic'
+ */
+export function detectPlatform(projectDir = process.cwd()) {
+  if (isClaudeCliAvailable()) return 'claude-cli';
+  if (isCursorProject(projectDir)) return 'cursor';
+  return 'generic';
+}
+
+function isClaudeCliAvailable() {
+  try {
+    execSync('claude --version', { stdio: 'pipe', timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isCursorProject(projectDir) {
+  return (
+    existsSync(join(projectDir, '.cursor')) ||
+    existsSync(join(projectDir, '.cursorrc')) ||
+    process.env.CURSOR_SESSION_ID != null
+  );
+}
+
+export function platformLabel(platform) {
+  const labels = {
+    'claude-cli': 'Claude Code CLI',
+    'cursor': 'Cursor IDE',
+    'generic': 'Generic (AGENT.md)',
+  };
+  return labels[platform] || platform;
+}

package/src/lib/ui.mjs

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+
+export const BANNER = `
+  ██████╗ ██╗    ██╗   ██╗  ██╗██╗████████╗
+  ██╔══██╗██║    ██║   ██║ ██╔╝██║╚══██╔══╝
+  ██║  ██║██║ █╗ ██║   █████╔╝ ██║   ██║
+  ██║  ██║██║███╗██║   ██╔═██╗ ██║   ██║
+  ██████╔╝╚███╔███╔╝   ██║  ██╗██║   ██║
+  ╚═════╝  ╚══╝╚══╝    ╚═╝  ╚═╝╚═╝   ╚═╝`;
+
+export function banner(subtitle) {
+  console.log(chalk.cyan.bold(BANNER));
+  if (subtitle) console.log(chalk.cyan(`  ${subtitle}`));
+  console.log();
+}
+
+export function header(text) {
+  console.log();
+  console.log(chalk.bold(`══════════════════════════════════════════`));
+  console.log(chalk.bold(`  ${text}`));
+  console.log(chalk.bold(`══════════════════════════════════════════`));
+}
+
+export const log = (msg) => console.log(`  ${msg}`);
+export const ok = (msg) => console.log(chalk.green(`  ✓  ${msg}`));
+export const warn = (msg) => console.log(chalk.yellow(`  ⚠  ${msg}`));
+export const err = (msg) => console.log(chalk.red(`  ✗  ${msg}`));
+export const info = (msg) => { console.log(); console.log(chalk.cyan(`▶ ${msg}`)); };
+export const dry = (msg) => console.log(chalk.dim(`  [dry-run] ${msg}`));
+
+export async function ask(question, defaultValue) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  try {
+    const answer = await rl.question(chalk.bold(`  ${question}${suffix}: `));
+    return answer.trim() || defaultValue || '';
+  } finally {
+    rl.close();
+  }
+}
+
+export async function choose(question, options, defaultValue) {
+  console.log(chalk.bold(`  ${question}`));
+  for (const opt of options) {
+    const marker = opt.value === defaultValue ? chalk.cyan(' [default]') : '';
+    console.log(`    ${opt.value} = ${opt.label}${marker}`);
+  }
+  const allowed = new Set(options.map((o) => o.value));
+  while (true) {
+    const answer = await ask('>', defaultValue);
+    if (allowed.has(answer)) return answer;
+    warn(`Invalid choice: "${answer}". Allowed: ${[...allowed].join(', ')}`);
+  }
+}
+
+export async function multiSelect(question, options, defaultValues) {
+  console.log(chalk.bold(`  ${question}`));
+  for (const opt of options) {
+    const marker = defaultValues?.includes(opt.value) ? chalk.dim(' (included)') : '';
+    console.log(`    ${opt.key} = ${opt.label}${marker}`);
+  }
+  const hint = defaultValues ? defaultValues.join(',') : '';
+  return ask('Enter numbers separated by comma', hint);
+}