worclaude 1.0.0

package/src/commands/restore.js

@@ -0,0 +1,95 @@
+import path from 'node:path';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { listBackups, restoreBackup } from '../core/backup.js';
+import { fileExists, dirExists } from '../utils/file.js';
+import { relativeTime } from '../utils/time.js';
+import * as display from '../utils/display.js';
+
+export async function restoreCommand() {
+  const projectRoot = process.cwd();
+
+  const backups = await listBackups(projectRoot);
+  if (backups.length === 0) {
+    display.info('No backups found. Run `worclaude backup` to create one.');
+    return;
+  }
+
+  display.header('Available Backups');
+  display.newline();
+
+  const choices = backups.map((b, i) => ({
+    name: `${path.basename(b.path)} (${relativeTime(b.dateString)})`,
+    value: i,
+  }));
+  choices.push(new inquirer.Separator());
+  choices.push({ name: '← Cancel', value: '__cancel__' });
+
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selected',
+      message: 'Select backup to restore:',
+      choices,
+    },
+  ]);
+
+  if (selected === '__cancel__') {
+    display.info('Restore cancelled.');
+    return;
+  }
+
+  const backup = backups[selected];
+
+  display.newline();
+  display.warn('This will replace your current Claude setup with the backup.');
+  display.dim('  Current files will be overwritten.');
+  display.newline();
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Confirm restore?',
+      default: false,
+    },
+  ]);
+
+  if (!confirm) {
+    display.info('Restore cancelled.');
+    return;
+  }
+
+  const spinner = ora('Restoring...').start();
+  try {
+    await restoreBackup(projectRoot, backup.path);
+    spinner.succeed('Restore complete!');
+  } catch (err) {
+    spinner.fail('Restore failed.');
+    display.error(err.message);
+    return;
+  }
+
+  display.newline();
+  display.success(`Restored from ${path.basename(backup.path)}/`);
+  display.newline();
+
+  // Show what was restored
+  const restored = [];
+  if (await fileExists(path.join(projectRoot, 'CLAUDE.md'))) restored.push('CLAUDE.md');
+  if (await dirExists(path.join(projectRoot, '.claude'))) restored.push('.claude/ (full directory)');
+  if (await fileExists(path.join(projectRoot, '.mcp.json'))) restored.push('.mcp.json');
+
+  if (restored.length > 0) {
+    display.info('Restored:');
+    for (const item of restored) {
+      display.dim(`  ${item}`);
+    }
+  }
+
+  display.newline();
+  display.info(
+    'Note: workflow-meta.json has been restored to its backup state.'
+  );
+  display.dim('  Run `worclaude upgrade` if you want to update to the latest version.');
+}

package/src/commands/status.js

@@ -0,0 +1,141 @@
+import path from 'node:path';
+import { readWorkflowMeta, workflowMetaExists } from '../core/config.js';
+import { hashFile } from '../utils/hash.js';
+import { fileExists, readFile, listFilesRecursive } from '../utils/file.js';
+import { TECH_STACKS } from '../data/agents.js';
+import * as display from '../utils/display.js';
+
+const TECH_DISPLAY_NAMES = Object.fromEntries(TECH_STACKS.map((t) => [t.value, t.name]));
+
+function countByPrefix(fileHashes, prefix) {
+  return Object.keys(fileHashes).filter((k) => k.startsWith(prefix)).length;
+}
+
+export async function statusCommand() {
+  const projectRoot = process.cwd();
+
+  if (!(await workflowMetaExists(projectRoot))) {
+    display.info('Workflow is not installed. Run `worclaude init` to set up.');
+    return;
+  }
+
+  const meta = await readWorkflowMeta(projectRoot);
+  if (!meta) {
+    display.error('workflow-meta.json is corrupted. Run `worclaude init` to reinstall.');
+    return;
+  }
+
+  display.header('Worclaude Status');
+  display.newline();
+
+  // Version and dates
+  display.dim(`  Version:      ${meta.version}`);
+  display.dim(`  Installed:    ${meta.installedAt?.split('T')[0] || 'unknown'}`);
+  display.dim(`  Last updated: ${meta.lastUpdated?.split('T')[0] || 'unknown'}`);
+  display.newline();
+
+  // Project info
+  const projectTypes = (meta.projectTypes || []).join(', ');
+  if (projectTypes) display.dim(`  Project type: ${projectTypes}`);
+
+  const techNames = (meta.techStack || [])
+    .map((t) => TECH_DISPLAY_NAMES[t] || t)
+    .join(', ');
+  if (techNames) display.dim(`  Tech stack:   ${techNames}`);
+  display.newline();
+
+  // Agents
+  const universalCount = (meta.universalAgents || []).length;
+  const optionalCount = (meta.optionalAgents || []).length;
+  const totalAgents = universalCount + optionalCount;
+  display.dim(`  Agents:       ${universalCount} universal + ${optionalCount} optional (${totalAgents} total)`);
+  if (optionalCount > 0) {
+    display.dim(`    Optional: ${meta.optionalAgents.join(', ')}`);
+  }
+  display.newline();
+
+  // Commands and skills counts
+  const commandCount = countByPrefix(meta.fileHashes || {}, 'commands/');
+  const skillCount = countByPrefix(meta.fileHashes || {}, 'skills/');
+  display.dim(`  Commands:     ${commandCount} installed`);
+  display.dim(`  Skills:       ${skillCount} installed`);
+  display.newline();
+
+  // Customized files
+  const customized = [];
+  for (const [key, storedHash] of Object.entries(meta.fileHashes || {})) {
+    const filePath = path.join(projectRoot, '.claude', ...key.split('/'));
+    if (await fileExists(filePath)) {
+      const currentHash = await hashFile(filePath);
+      if (currentHash !== storedHash) {
+        customized.push(`.claude/${key}`);
+      }
+    }
+  }
+
+  // Check CLAUDE.md separately
+  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+  if (await fileExists(claudeMdPath)) {
+    // CLAUDE.md is always considered potentially customized
+    customized.push('CLAUDE.md');
+  }
+
+  if (customized.length > 0) {
+    display.info('Customized files (differ from installed version):');
+    for (const f of customized) {
+      display.dim(`    ~ ${f}`);
+    }
+    display.newline();
+  }
+
+  // Pending review files
+  const pendingReview = [];
+  try {
+    const claudeDir = path.join(projectRoot, '.claude');
+    const allFiles = await listFilesRecursive(claudeDir);
+    for (const fp of allFiles) {
+      const rel = path.relative(claudeDir, fp).split(path.sep).join('/');
+      if (rel.endsWith('.workflow-ref.md')) {
+        pendingReview.push(`.claude/${rel}`);
+      }
+    }
+  } catch {
+    // .claude dir might not exist
+  }
+
+  const suggestionsPath = path.join(projectRoot, 'CLAUDE.md.workflow-suggestions');
+  if (await fileExists(suggestionsPath)) {
+    pendingReview.push('CLAUDE.md.workflow-suggestions');
+  }
+
+  if (pendingReview.length > 0) {
+    display.warn('Pending review:');
+    for (const f of pendingReview) {
+      display.dim(`    ⚠ ${f}`);
+    }
+    display.newline();
+  }
+
+  // Settings info
+  const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+  if (await fileExists(settingsPath)) {
+    try {
+      const raw = await readFile(settingsPath);
+      const settings = JSON.parse(raw);
+
+      const allow = settings.permissions?.allow || [];
+      const permCount = allow.filter((p) => !p.trim().startsWith('//')).length;
+
+      const hooks = settings.hooks || {};
+      const hookCount = Object.values(hooks).reduce(
+        (sum, entries) => sum + entries.length,
+        0
+      );
+
+      display.dim(`  Hooks:        ${hookCount} active`);
+      display.dim(`  Permissions:  ${permCount} rules`);
+    } catch {
+      display.dim('  Settings:     (could not parse settings.json)');
+    }
+  }
+}

package/src/commands/upgrade.js

@@ -0,0 +1,208 @@
+import path from 'node:path';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import {
+  readWorkflowMeta,
+  workflowMetaExists,
+  writeWorkflowMeta,
+  getPackageVersion,
+} from '../core/config.js';
+import { createBackup } from '../core/backup.js';
+import { categorizeFiles } from '../core/file-categorizer.js';
+import { buildSettingsJson, mergeSettingsPermissionsAndHooks } from '../core/merger.js';
+import { readTemplate } from '../core/scaffolder.js';
+import { hashFile } from '../utils/hash.js';
+import { writeFile, fileExists, listFilesRecursive } from '../utils/file.js';
+import * as display from '../utils/display.js';
+
+export async function upgradeCommand() {
+  const projectRoot = process.cwd();
+
+  // 1. Check prerequisite
+  if (!(await workflowMetaExists(projectRoot))) {
+    display.error('No workflow installation found.');
+    display.info('Run `worclaude init` to set up the workflow first.');
+    return;
+  }
+
+  const meta = await readWorkflowMeta(projectRoot);
+  if (!meta) {
+    display.error('workflow-meta.json is corrupted or invalid.');
+    display.info('Run `worclaude init` to reinstall (a backup will be created first).');
+    return;
+  }
+
+  // 2. Version comparison
+  const currentVersion = await getPackageVersion();
+  const installedVersion = meta.version;
+
+  if (installedVersion === currentVersion) {
+    display.success(`Already up to date (v${currentVersion}).`);
+    return;
+  }
+
+  // 3. Categorize files
+  const categories = await categorizeFiles(projectRoot, meta);
+
+  // 4. Preview
+  display.header('Worclaude Upgrade');
+  display.newline();
+  display.dim(`  Current version: ${installedVersion}`);
+  display.dim(`  New version:     ${currentVersion}`);
+  display.newline();
+
+  display.info('Changes:');
+
+  if (categories.autoUpdate.length > 0) {
+    display.dim('  Auto-update (unchanged since install):');
+    const showCount = Math.min(categories.autoUpdate.length, 3);
+    for (let i = 0; i < showCount; i++) {
+      display.dim(`    ✓ ${categories.autoUpdate[i].key}`);
+    }
+    if (categories.autoUpdate.length > 3) {
+      display.dim(`    ✓ ${categories.autoUpdate.length - 3} more files`);
+    }
+    display.newline();
+  }
+
+  if (categories.conflict.length > 0) {
+    display.dim('  Needs review (you\'ve customized these):');
+    for (const { key } of categories.conflict) {
+      display.dim(`    ~ ${key} (modified since install)`);
+    }
+    display.newline();
+  }
+
+  if (categories.newFiles.length > 0) {
+    display.dim('  New in this version:');
+    for (const { key } of categories.newFiles) {
+      display.dim(`    + ${key}`);
+    }
+    display.newline();
+  }
+
+  if (categories.unchanged.length > 0) {
+    display.dim(`  Unchanged (no updates needed): ${categories.unchanged.length} files`);
+    display.newline();
+  }
+
+  if (categories.modified.length > 0) {
+    display.dim('  Your customizations (no workflow updates available):');
+    for (const { key } of categories.modified) {
+      display.dim(`    ~ ${key}`);
+    }
+    display.newline();
+  }
+
+  const hasWork =
+    categories.autoUpdate.length > 0 ||
+    categories.conflict.length > 0 ||
+    categories.newFiles.length > 0;
+
+  if (!hasWork) {
+    display.info('No file changes needed — only updating version metadata.');
+    display.newline();
+  }
+
+  // 5. Confirm
+  const { proceed } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'proceed',
+      message: 'Proceed with upgrade?',
+      choices: [
+        { name: 'Yes', value: true },
+        { name: 'No', value: false },
+      ],
+    },
+  ]);
+
+  if (!proceed) {
+    display.info('Upgrade cancelled.');
+    return;
+  }
+
+  // 6. Execute
+  const spinner = ora('Upgrading...').start();
+
+  try {
+    // Create backup first
+    const backupDir = await createBackup(projectRoot);
+    spinner.text = 'Backup created, applying updates...';
+
+    // Auto-update files
+    for (const { key, templatePath } of categories.autoUpdate) {
+      const content = await readTemplate(templatePath);
+      await writeFile(path.join(projectRoot, '.claude', ...key.split('/')), content);
+    }
+
+    // Conflict files: save as .workflow-ref.md
+    for (const { key, templatePath } of categories.conflict) {
+      const content = await readTemplate(templatePath);
+      const refKey = key.replace(/\.md$/, '.workflow-ref.md');
+      await writeFile(path.join(projectRoot, '.claude', ...refKey.split('/')), content);
+    }
+
+    // New files: add directly
+    for (const { key, templatePath } of categories.newFiles) {
+      const content = await readTemplate(templatePath);
+      await writeFile(path.join(projectRoot, '.claude', ...key.split('/')), content);
+    }
+
+    // Settings.json merge: append new permissions and hooks
+    const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+    if (await fileExists(settingsPath)) {
+      const techStack = meta.techStack || [];
+      const useDocker = meta.useDocker || false;
+      const { settingsObject: workflowSettings } = await buildSettingsJson(techStack, useDocker);
+      const settingsReport = { added: { permissions: 0, hooks: 0 }, hookConflicts: [] };
+      await mergeSettingsPermissionsAndHooks(projectRoot, workflowSettings, settingsReport);
+      spinner.text = 'Settings merged...';
+    }
+
+    // Recompute file hashes
+    const fileHashes = {};
+    const claudeDir = path.join(projectRoot, '.claude');
+    const allFiles = await listFilesRecursive(claudeDir);
+    for (const filePath of allFiles) {
+      const relKey = path.relative(claudeDir, filePath).split(path.sep).join('/');
+      if (relKey !== 'workflow-meta.json' && relKey !== 'settings.json') {
+        fileHashes[relKey] = await hashFile(filePath);
+      }
+    }
+
+    // Update meta
+    meta.version = currentVersion;
+    meta.lastUpdated = new Date().toISOString();
+    meta.fileHashes = fileHashes;
+    await writeWorkflowMeta(projectRoot, meta);
+
+    spinner.succeed(`Upgrade complete! (${installedVersion} → ${currentVersion})`);
+
+    // 7. Display report
+    display.newline();
+    if (categories.autoUpdate.length > 0) {
+      display.dim(`  Updated:     ${categories.autoUpdate.length} files`);
+    }
+    if (categories.conflict.length > 0) {
+      display.dim(`  Conflicts:   ${categories.conflict.length} files (saved as .workflow-ref.md)`);
+    }
+    if (categories.newFiles.length > 0) {
+      display.dim(`  New:         ${categories.newFiles.length} files added`);
+    }
+    display.dim(`  Unchanged:   ${categories.unchanged.length} files`);
+    if (categories.modified.length > 0) {
+      display.dim(`  Customized:  ${categories.modified.length} files (no updates needed)`);
+    }
+    display.newline();
+    display.dim(`  Backup: ${path.basename(backupDir)}/`);
+
+    if (categories.conflict.length > 0) {
+      display.newline();
+      display.info('Review .workflow-ref.md files and merge what\'s useful.');
+    }
+  } catch (err) {
+    spinner.fail('Upgrade failed.');
+    display.error(err.message);
+  }
+}

package/src/core/backup.js

@@ -0,0 +1,94 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import {
+  fileExists,
+  dirExists,
+  copyFile,
+  copyDirectory,
+  removeDirectory,
+  ensureDir,
+} from '../utils/file.js';
+
+function generateTimestamp() {
+  const now = new Date();
+  const pad = (n, len = 2) => String(n).padStart(len, '0');
+  const date = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+  const time = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  return `${date}-${time}`;
+}
+
+export async function createBackup(projectRoot) {
+  const timestamp = generateTimestamp();
+  const backupDir = path.join(projectRoot, `.claude-backup-${timestamp}`);
+  await ensureDir(backupDir);
+
+  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+  if (await fileExists(claudeMdPath)) {
+    await copyFile(claudeMdPath, path.join(backupDir, 'CLAUDE.md'));
+  }
+
+  const claudeDir = path.join(projectRoot, '.claude');
+  if (await dirExists(claudeDir)) {
+    await copyDirectory(claudeDir, path.join(backupDir, '.claude'));
+  }
+
+  const mcpPath = path.join(projectRoot, '.mcp.json');
+  if (await fileExists(mcpPath)) {
+    await copyFile(mcpPath, path.join(backupDir, '.mcp.json'));
+  }
+
+  return backupDir;
+}
+
+export async function listBackups(projectRoot) {
+  const BACKUP_PATTERN = /^\.claude-backup-(\d{8}-\d{6})$/;
+  let entries;
+  try {
+    entries = await fs.readdir(projectRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const backups = entries
+    .filter((e) => e.isDirectory() && BACKUP_PATTERN.test(e.name))
+    .map((e) => {
+      const match = e.name.match(BACKUP_PATTERN);
+      const timestamp = match[1];
+      // Parse YYYYMMDD-HHMMSS into readable date
+      const year = timestamp.slice(0, 4);
+      const month = timestamp.slice(4, 6);
+      const day = timestamp.slice(6, 8);
+      const hour = timestamp.slice(9, 11);
+      const min = timestamp.slice(11, 13);
+      const sec = timestamp.slice(13, 15);
+      return {
+        path: path.join(projectRoot, e.name),
+        timestamp,
+        dateString: `${year}-${month}-${day} ${hour}:${min}:${sec}`,
+      };
+    })
+    .sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+
+  return backups;
+}
+
+export async function restoreBackup(projectRoot, backupPath) {
+  const backupClaudeMd = path.join(backupPath, 'CLAUDE.md');
+  if (await fileExists(backupClaudeMd)) {
+    await copyFile(backupClaudeMd, path.join(projectRoot, 'CLAUDE.md'));
+  }
+
+  const backupClaudeDir = path.join(backupPath, '.claude');
+  if (await dirExists(backupClaudeDir)) {
+    const existingClaudeDir = path.join(projectRoot, '.claude');
+    if (await dirExists(existingClaudeDir)) {
+      await removeDirectory(existingClaudeDir);
+    }
+    await copyDirectory(backupClaudeDir, existingClaudeDir);
+  }
+
+  const backupMcp = path.join(backupPath, '.mcp.json');
+  if (await fileExists(backupMcp)) {
+    await copyFile(backupMcp, path.join(projectRoot, '.mcp.json'));
+  }
+}

package/src/core/config.js

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFile, writeFile, fileExists } from '../utils/file.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function getPackageVersion() {
+  const pkgPath = path.resolve(__dirname, '..', '..', 'package.json');
+  const content = await readFile(pkgPath);
+  return JSON.parse(content).version;
+}
+
+export function createWorkflowMeta({
+  projectTypes,
+  techStack,
+  universalAgents,
+  optionalAgents,
+  fileHashes = {},
+  version,
+  useDocker = false,
+}) {
+  const now = new Date().toISOString();
+  return {
+    version: version || '1.0.0',
+    installedAt: now,
+    lastUpdated: now,
+    projectTypes,
+    techStack,
+    universalAgents,
+    optionalAgents,
+    useDocker,
+    fileHashes,
+  };
+}
+
+export async function readWorkflowMeta(projectRoot) {
+  const metaPath = path.join(projectRoot, '.claude', 'workflow-meta.json');
+  try {
+    const content = await readFile(metaPath);
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+export async function workflowMetaExists(projectRoot) {
+  const metaPath = path.join(projectRoot, '.claude', 'workflow-meta.json');
+  return fileExists(metaPath);
+}
+
+export async function writeWorkflowMeta(projectRoot, meta) {
+  const metaPath = path.join(projectRoot, '.claude', 'workflow-meta.json');
+  await writeFile(metaPath, JSON.stringify(meta, null, 2));
+}

package/src/core/detector.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { fileExists, dirExists, readFile, listFiles } from '../utils/file.js';
+import { workflowMetaExists } from './config.js';
+
+export async function detectScenario(projectRoot) {
+  if (await workflowMetaExists(projectRoot)) {
+    return 'upgrade';
+  }
+
+  const hasClaudeDir = await dirExists(path.join(projectRoot, '.claude'));
+  const hasClaudeMd = await fileExists(path.join(projectRoot, 'CLAUDE.md'));
+  const hasMcpJson = await fileExists(path.join(projectRoot, '.mcp.json'));
+
+  if (hasClaudeDir || hasClaudeMd || hasMcpJson) {
+    return 'existing';
+  }
+
+  return 'fresh';
+}
+
+export async function scanExistingSetup(projectRoot) {
+  const hasClaudeDir = await dirExists(path.join(projectRoot, '.claude'));
+  const hasClaudeMd = await fileExists(path.join(projectRoot, 'CLAUDE.md'));
+
+  let claudeMdLineCount = 0;
+  if (hasClaudeMd) {
+    const content = await readFile(path.join(projectRoot, 'CLAUDE.md'));
+    claudeMdLineCount = content.split(/\r?\n/).length;
+  }
+
+  return {
+    hasClaudeDir,
+    hasClaudeMd,
+    claudeMdLineCount,
+    hasSettingsJson: await fileExists(path.join(projectRoot, '.claude', 'settings.json')),
+    hasMcpJson: await fileExists(path.join(projectRoot, '.mcp.json')),
+    existingSkills: await listFiles(path.join(projectRoot, '.claude', 'skills')),
+    existingAgents: await listFiles(path.join(projectRoot, '.claude', 'agents')),
+    existingCommands: await listFiles(path.join(projectRoot, '.claude', 'commands')),
+    hasProgressMd: await fileExists(path.join(projectRoot, 'docs', 'spec', 'PROGRESS.md')),
+    hasSpecMd: await fileExists(path.join(projectRoot, 'docs', 'spec', 'SPEC.md')),
+  };
+}