safeword 0.2.2 → 0.2.4

package/packages/cli/src/commands/diff.ts

@@ -0,0 +1,209 @@
+/**
+ * Diff command - Preview changes that would be made by upgrade
+ */
+
+import { join } from 'node:path';
+import { VERSION } from '../version.js';
+import { exists, readFileSafe, getTemplatesDir } from '../utils/fs.js';
+import { info, success, error, header, listItem } from '../utils/output.js';
+
+export interface DiffOptions {
+  verbose?: boolean;
+}
+
+interface FileDiff {
+  path: string;
+  status: 'added' | 'modified' | 'unchanged';
+  currentContent?: string;
+  newContent: string;
+}
+
+/**
+ * Create a unified diff between two strings
+ */
+function createUnifiedDiff(oldContent: string, newContent: string, filename: string): string {
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+
+  const lines: string[] = [];
+  lines.push(`--- a/${filename}`);
+  lines.push(`+++ b/${filename}`);
+
+  // Simple diff - show all changes
+  // A real implementation would use a proper diff algorithm
+  let hasChanges = false;
+
+  const maxLines = Math.max(oldLines.length, newLines.length);
+
+  for (let i = 0; i < maxLines; i++) {
+    const oldLine = oldLines[i];
+    const newLine = newLines[i];
+
+    if (oldLine === newLine) {
+      lines.push(` ${oldLine ?? ''}`);
+    } else {
+      hasChanges = true;
+      if (oldLine !== undefined) {
+        lines.push(`-${oldLine}`);
+      }
+      if (newLine !== undefined) {
+        lines.push(`+${newLine}`);
+      }
+    }
+  }
+
+  if (!hasChanges) {
+    return '';
+  }
+
+  // Add context marker
+  lines.splice(2, 0, `@@ -1,${oldLines.length} +1,${newLines.length} @@`);
+
+  return lines.join('\n');
+}
+
+/**
+ * Get all files that would be changed by upgrade
+ */
+function getFileDiffs(cwd: string): FileDiff[] {
+  const templatesDir = getTemplatesDir();
+  const diffs: FileDiff[] = [];
+
+  // Define files to check (template source -> install destination)
+  const files: Array<{ templatePath: string; installPath: string }> = [
+    { templatePath: 'SAFEWORD.md', installPath: '.safeword/SAFEWORD.md' },
+    { templatePath: 'hooks/agents-md-check.sh', installPath: '.safeword/hooks/agents-md-check.sh' },
+    { templatePath: 'hooks/pre-commit.sh', installPath: '.safeword/hooks/pre-commit.sh' },
+    { templatePath: 'hooks/post-tool.sh', installPath: '.safeword/hooks/post-tool.sh' },
+    { templatePath: 'hooks/inject-timestamp.sh', installPath: '.safeword/hooks/inject-timestamp.sh' },
+    { templatePath: 'skills/safeword-quality-reviewer/SKILL.md', installPath: '.claude/skills/safeword-quality-reviewer/SKILL.md' },
+  ];
+
+  // Add version file (not from templates)
+  const versionPath = join(cwd, '.safeword/version');
+  const currentVersion = readFileSafe(versionPath);
+  if (currentVersion === null) {
+    diffs.push({ path: '.safeword/version', status: 'added', newContent: VERSION });
+  } else if (currentVersion.trim() !== VERSION) {
+    diffs.push({ path: '.safeword/version', status: 'modified', currentContent: currentVersion, newContent: VERSION });
+  } else {
+    diffs.push({ path: '.safeword/version', status: 'unchanged', currentContent: currentVersion, newContent: VERSION });
+  }
+
+  for (const file of files) {
+    const templateFullPath = join(templatesDir, file.templatePath);
+    const installFullPath = join(cwd, file.installPath);
+
+    const newContent = readFileSafe(templateFullPath);
+    if (newContent === null) continue; // Skip if template doesn't exist
+
+    const currentContent = readFileSafe(installFullPath);
+
+    if (currentContent === null) {
+      diffs.push({
+        path: file.installPath,
+        status: 'added',
+        newContent,
+      });
+    } else if (currentContent.trim() !== newContent.trim()) {
+      diffs.push({
+        path: file.installPath,
+        status: 'modified',
+        currentContent,
+        newContent,
+      });
+    } else {
+      diffs.push({
+        path: file.installPath,
+        status: 'unchanged',
+        currentContent,
+        newContent,
+      });
+    }
+  }
+
+  return diffs;
+}
+
+export async function diff(options: DiffOptions): Promise<void> {
+  const cwd = process.cwd();
+  const safewordDir = join(cwd, '.safeword');
+
+  // Check if configured
+  if (!exists(safewordDir)) {
+    error('Not configured. Run `safeword setup` first.');
+    process.exit(1);
+  }
+
+  // Read project version
+  const versionPath = join(safewordDir, 'version');
+  const projectVersion = readFileSafe(versionPath)?.trim() ?? 'unknown';
+
+  header('Safeword Diff');
+  info(`Changes from v${projectVersion} → v${VERSION}`);
+
+  const diffs = getFileDiffs(cwd);
+
+  const added = diffs.filter(d => d.status === 'added');
+  const modified = diffs.filter(d => d.status === 'modified');
+  const unchanged = diffs.filter(d => d.status === 'unchanged');
+
+  // Summary
+  info(
+    `\nSummary: ${added.length} added, ${modified.length} modified, ${unchanged.length} unchanged`,
+  );
+
+  // List by category
+  if (added.length > 0) {
+    info('\nAdded:');
+    for (const file of added) {
+      listItem(file.path);
+    }
+  }
+
+  if (modified.length > 0) {
+    info('\nModified:');
+    for (const file of modified) {
+      listItem(file.path);
+    }
+  }
+
+  if (unchanged.length > 0) {
+    info('\nUnchanged:');
+    for (const file of unchanged) {
+      listItem(file.path);
+    }
+  }
+
+  // Verbose output - show actual diffs
+  if (options.verbose) {
+    header('Detailed Changes');
+
+    for (const file of modified) {
+      if (file.currentContent) {
+        info(`\n${file.path}:`);
+        const diffOutput = createUnifiedDiff(file.currentContent, file.newContent, file.path);
+        if (diffOutput) {
+          console.log(diffOutput);
+        }
+      }
+    }
+
+    for (const file of added) {
+      info(`\n${file.path}: (new file)`);
+      const lines = file.newContent.split('\n').slice(0, 10);
+      for (const line of lines) {
+        console.log(`+${line}`);
+      }
+      if (file.newContent.split('\n').length > 10) {
+        console.log('... (truncated)');
+      }
+    }
+  }
+
+  if (added.length === 0 && modified.length === 0) {
+    success('\nNo changes needed - configuration is up to date');
+  } else {
+    info('\nRun `safeword upgrade` to apply these changes');
+  }
+}

package/packages/cli/src/commands/reset.ts

@@ -0,0 +1,190 @@
+/**
+ * Reset command - Remove safeword configuration from project
+ */
+
+import { join } from 'node:path';
+import { exists, remove, readJson, writeJson, listDir } from '../utils/fs.js';
+import { info, success, error, header, listItem } from '../utils/output.js';
+import { isGitRepo, removeGitHook } from '../utils/git.js';
+import { filterOutSafewordHooks } from '../utils/hooks.js';
+import { removeAgentsMdLink } from '../utils/agents-md.js';
+
+export interface ResetOptions {
+  yes?: boolean;
+}
+
+export async function reset(options: ResetOptions): Promise<void> {
+  const cwd = process.cwd();
+  const safewordDir = join(cwd, '.safeword');
+
+  // Check if configured
+  if (!exists(safewordDir)) {
+    info('Nothing to remove. Project is not configured with safeword.');
+    return;
+  }
+
+  const isNonInteractive = options.yes || !process.stdin.isTTY;
+
+  // Confirmation (in interactive mode without --yes)
+  if (!isNonInteractive) {
+    // In a real implementation, we'd prompt here
+    // For now, non-TTY mode auto-confirms
+  }
+
+  header('Safeword Reset');
+  info('Removing safeword configuration...');
+
+  const removed: string[] = [];
+
+  try {
+    // 1. Remove .safeword directory
+    if (exists(safewordDir)) {
+      remove(safewordDir);
+      removed.push('.safeword/');
+      success('Removed .safeword directory');
+    }
+
+    // 2. Remove safeword hooks from .claude/settings.json
+    const settingsPath = join(cwd, '.claude', 'settings.json');
+
+    if (exists(settingsPath)) {
+      info('\nRemoving hooks from .claude/settings.json...');
+
+      interface SettingsJson {
+        hooks?: Record<string, unknown[]>;
+        [key: string]: unknown;
+      }
+
+      const settings = readJson<SettingsJson>(settingsPath);
+
+      if (settings?.hooks) {
+        let modified = false;
+
+        for (const [event, hooks] of Object.entries(settings.hooks)) {
+          if (Array.isArray(hooks)) {
+            const filtered = filterOutSafewordHooks(hooks);
+            if (filtered.length !== hooks.length) {
+              settings.hooks[event] = filtered;
+              modified = true;
+            }
+          }
+        }
+
+        if (modified) {
+          writeJson(settingsPath, settings);
+          removed.push('.claude/settings.json (hooks)');
+          success('Removed safeword hooks');
+        }
+      }
+    }
+
+    // 3. Remove safeword skills
+    const skillsDir = join(cwd, '.claude', 'skills');
+
+    if (exists(skillsDir)) {
+      info('\nRemoving safeword skills...');
+
+      const skills = listDir(skillsDir);
+      for (const skill of skills) {
+        if (skill.startsWith('safeword-')) {
+          remove(join(skillsDir, skill));
+          removed.push(`.claude/skills/${skill}/`);
+        }
+      }
+
+      if (removed.some(r => r.includes('skills'))) {
+        success('Removed safeword skills');
+      }
+    }
+
+    // 3.5. Remove safeword slash commands
+    const commandsDir = join(cwd, '.claude', 'commands');
+    const safewordCommands = ['quality-review.md', 'arch-review.md', 'lint.md'];
+
+    if (exists(commandsDir)) {
+      info('\nRemoving safeword commands...');
+
+      let commandsRemoved = false;
+      for (const cmd of safewordCommands) {
+        const cmdPath = join(commandsDir, cmd);
+        if (exists(cmdPath)) {
+          remove(cmdPath);
+          removed.push(`.claude/commands/${cmd}`);
+          commandsRemoved = true;
+        }
+      }
+
+      if (commandsRemoved) {
+        success('Removed safeword commands');
+      }
+    }
+
+    // 3.6. Remove MCP servers from .mcp.json
+    const mcpConfigPath = join(cwd, '.mcp.json');
+
+    if (exists(mcpConfigPath)) {
+      info('\nRemoving MCP servers...');
+
+      interface McpConfig {
+        mcpServers?: Record<string, unknown>;
+        [key: string]: unknown;
+      }
+
+      const mcpConfig = readJson<McpConfig>(mcpConfigPath);
+
+      if (mcpConfig?.mcpServers) {
+        // Remove safeword MCP servers
+        delete mcpConfig.mcpServers.context7;
+        delete mcpConfig.mcpServers.playwright;
+
+        // If no servers left, remove the file
+        if (Object.keys(mcpConfig.mcpServers).length === 0) {
+          remove(mcpConfigPath);
+          removed.push('.mcp.json');
+        } else {
+          writeJson(mcpConfigPath, mcpConfig);
+          removed.push('.mcp.json (context7, playwright)');
+        }
+
+        success('Removed MCP servers');
+      }
+    }
+
+    // 4. Remove git hook markers
+    if (isGitRepo(cwd)) {
+      info('\nRemoving git hook markers...');
+      removeGitHook(cwd);
+      removed.push('.git/hooks/pre-commit (markers)');
+      success('Removed git hook markers');
+    }
+
+    // 5. Remove link from AGENTS.md
+    info('\nCleaning AGENTS.md...');
+    if (removeAgentsMdLink(cwd)) {
+      removed.push('AGENTS.md (link)');
+      success('Removed safeword link from AGENTS.md');
+    }
+
+    // Print summary
+    header('Reset Complete');
+
+    if (removed.length > 0) {
+      info('\nRemoved:');
+      for (const item of removed) {
+        listItem(item);
+      }
+    }
+
+    // Note about preserved linting
+    info('\nPreserved (remove manually if desired):');
+    listItem('eslint.config.mjs');
+    listItem('.prettierrc');
+    listItem('package.json lint/format scripts');
+    listItem('ESLint/Prettier devDependencies');
+
+    success('\nSafeword configuration removed');
+  } catch (err) {
+    error(`Reset failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}