safeword 0.2.2 → 0.2.4

package/packages/cli/tests/commands/setup-noninteractive.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Test Suite 6: Non-Interactive Setup
+ *
+ * Tests for CI/headless operation.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  createTempDir,
+  removeTempDir,
+  createTypeScriptPackageJson,
+  runCli,
+  fileExists,
+} from '../helpers';
+
+describe('Test Suite 6: Non-Interactive Setup', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+  });
+
+  afterEach(() => {
+    removeTempDir(tempDir);
+  });
+
+  describe('Test 6.1: --yes flag skips all prompts', () => {
+    it('should complete without hanging', async () => {
+      createTypeScriptPackageJson(tempDir);
+      // No git init - should skip git prompt with --yes
+
+      const result = await runCli(['setup', '--yes'], {
+        cwd: tempDir,
+        timeout: 30000,
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(fileExists(tempDir, '.safeword')).toBe(true);
+
+      // Git should be skipped (no .git created)
+      expect(fileExists(tempDir, '.git')).toBe(false);
+    });
+  });
+
+  describe('Test 6.2: No TTY uses defaults', () => {
+    it('should complete without stdin in non-TTY mode', async () => {
+      createTypeScriptPackageJson(tempDir);
+      // No git init
+
+      // Force non-TTY by setting environment
+      const result = await runCli(['setup'], {
+        cwd: tempDir,
+        timeout: 30000,
+        env: {
+          CI: 'true', // Many tools detect CI and use non-interactive mode
+          TERM: 'dumb',
+        },
+      });
+
+      // Should complete (either with defaults or --yes required message)
+      // The exact behavior depends on implementation
+      expect(result.exitCode).toBeDefined();
+    });
+  });
+
+  describe('Test 6.3: Warning shown when git skipped', () => {
+    it('should show warning about skipped git initialization', async () => {
+      createTypeScriptPackageJson(tempDir);
+      // No git init
+
+      const result = await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(result.exitCode).toBe(0);
+
+      // Should mention skipped git
+      const output = result.stdout + result.stderr;
+      expect(output.toLowerCase()).toMatch(/skipped|git|warning/i);
+    });
+  });
+});

package/packages/cli/tests/commands/setup-templates.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Test Suite: Setup - Template Bundling (Story 1)
+ *
+ * Tests for the "self-contained templates" feature.
+ * The CLI should bundle full methodology files (not stubs) so
+ * `npx safeword setup` works without external dependencies.
+ *
+ * First 3 tests FAIL until Story 1 is implemented.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  createTempDir,
+  removeTempDir,
+  createTypeScriptPackageJson,
+  runCli,
+  readTestFile,
+  writeTestFile,
+  fileExists,
+  initGitRepo,
+} from '../helpers';
+
+describe('Setup - Template Bundling (Story 1)', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+  });
+
+  afterEach(() => {
+    removeTempDir(tempDir);
+  });
+
+  it('should install full SAFEWORD.md (not a stub)', async () => {
+    createTypeScriptPackageJson(tempDir);
+    initGitRepo(tempDir);
+
+    await runCli(['setup', '--yes'], { cwd: tempDir });
+
+    expect(fileExists(tempDir, '.safeword/SAFEWORD.md')).toBe(true);
+
+    const content = readTestFile(tempDir, '.safeword/SAFEWORD.md');
+    // Full file is ~31KB, stub is <1KB
+    expect(content.length).toBeGreaterThan(1000);
+    // Verify it's the full methodology file, not a stub
+    expect(content).toContain('# Global Instructions for AI Coding Agents');
+  });
+
+  it('should install methodology guides to .safeword/guides/', async () => {
+    createTypeScriptPackageJson(tempDir);
+    initGitRepo(tempDir);
+
+    await runCli(['setup', '--yes'], { cwd: tempDir });
+
+    expect(fileExists(tempDir, '.safeword/guides')).toBe(true);
+
+    const guidesDir = join(tempDir, '.safeword/guides');
+    const mdFiles = readdirSync(guidesDir).filter((f) => f.endsWith('.md'));
+
+    expect(mdFiles.length).toBeGreaterThan(0);
+  });
+
+  it('should install document templates', async () => {
+    createTypeScriptPackageJson(tempDir);
+    initGitRepo(tempDir);
+
+    await runCli(['setup', '--yes'], { cwd: tempDir });
+
+    expect(fileExists(tempDir, '.safeword/templates')).toBe(true);
+
+    const templatesDir = join(tempDir, '.safeword/templates');
+    const mdFiles = readdirSync(templatesDir).filter((f) => f.endsWith('.md'));
+
+    expect(mdFiles.length).toBeGreaterThan(0);
+  });
+
+  it('should install review prompts to .safeword/prompts/', async () => {
+    createTypeScriptPackageJson(tempDir);
+    initGitRepo(tempDir);
+
+    await runCli(['setup', '--yes'], { cwd: tempDir });
+
+    expect(fileExists(tempDir, '.safeword/prompts')).toBe(true);
+
+    const promptsDir = join(tempDir, '.safeword/prompts');
+    const mdFiles = readdirSync(promptsDir).filter((f) => f.endsWith('.md'));
+
+    // Should have 2 review prompts
+    expect(mdFiles.length).toBeGreaterThan(0);
+  });
+
+  it('should block re-run and preserve user content', async () => {
+    createTypeScriptPackageJson(tempDir);
+    initGitRepo(tempDir);
+
+    await runCli(['setup', '--yes'], { cwd: tempDir });
+
+    // Create user content
+    writeTestFile(
+      tempDir,
+      '.safeword/learnings/my-learning.md',
+      '# My Learning\n\nImportant info.',
+    );
+
+    // Re-run setup should exit with error (already configured)
+    const result = await runCli(['setup', '--yes'], { cwd: tempDir });
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr).toContain('Already configured');
+
+    // User content should be untouched
+    expect(fileExists(tempDir, '.safeword/learnings/my-learning.md')).toBe(true);
+    const content = readTestFile(tempDir, '.safeword/learnings/my-learning.md');
+    expect(content).toContain('My Learning');
+  });
+
+  it('should have no broken internal links in installed templates', async () => {
+    createTypeScriptPackageJson(tempDir);
+    initGitRepo(tempDir);
+
+    await runCli(['setup', '--yes'], { cwd: tempDir });
+
+    // Collect all markdown files in .safeword/
+    const safewordDir = join(tempDir, '.safeword');
+    const allMdFiles: string[] = [];
+
+    function collectMdFiles(dir: string) {
+      if (!fileExists(tempDir, dir.replace(tempDir + '/', ''))) return;
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          collectMdFiles(fullPath);
+        } else if (entry.name.endsWith('.md')) {
+          allMdFiles.push(fullPath);
+        }
+      }
+    }
+
+    collectMdFiles(safewordDir);
+
+    // Must have at least SAFEWORD.md with links to verify
+    expect(allMdFiles.length).toBeGreaterThan(0);
+
+    // Extract all @./.safeword/ links and verify targets exist
+    // Pattern: @./.safeword/path.md - stop at whitespace, backticks, quotes, parens, or markdown formatting
+    const linkPattern = /@\.\/\.safeword\/[a-zA-Z0-9_\-/]+\.md/g;
+    const brokenLinks: { file: string; link: string }[] = [];
+    let totalLinks = 0;
+
+    for (const mdFile of allMdFiles) {
+      const content = readFileSync(mdFile, 'utf-8');
+      const links = content.match(linkPattern) || [];
+      totalLinks += links.length;
+
+      for (const link of links) {
+        // Convert @./.safeword/path to relative path
+        const relativePath = link.replace('@./', '');
+
+        if (!fileExists(tempDir, relativePath)) {
+          brokenLinks.push({
+            file: mdFile.replace(tempDir + '/', ''),
+            link,
+          });
+        }
+      }
+    }
+
+    // Report all broken links
+    if (brokenLinks.length > 0) {
+      const report = brokenLinks
+        .map((b) => `  ${b.file}: ${b.link}`)
+        .join('\n');
+      expect.fail(`Found ${brokenLinks.length} broken links:\n${report}`);
+    }
+
+    // Should have found at least some links to validate
+    expect(totalLinks).toBeGreaterThan(0);
+  });
+});

package/packages/cli/tests/commands/upgrade.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Test Suite 9: Upgrade
+ *
+ * Tests for `safeword upgrade` command.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  createTempDir,
+  removeTempDir,
+  createTypeScriptPackageJson,
+  createConfiguredProject,
+  runCli,
+  readTestFile,
+  writeTestFile,
+  fileExists,
+} from '../helpers';
+
+describe('Test Suite 9: Upgrade', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+  });
+
+  afterEach(() => {
+    removeTempDir(tempDir);
+  });
+
+  describe('Test 9.1: Overwrites .safeword files', () => {
+    it('should restore modified files to CLI version', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Modify a safeword file
+      const originalContent = readTestFile(tempDir, '.safeword/SAFEWORD.md');
+      writeTestFile(tempDir, '.safeword/SAFEWORD.md', '# Modified content\n');
+
+      await runCli(['upgrade'], { cwd: tempDir });
+
+      const restoredContent = readTestFile(tempDir, '.safeword/SAFEWORD.md');
+      // Should be restored (not the modified content)
+      expect(restoredContent).not.toBe('# Modified content\n');
+    });
+
+    it('should update .safeword/version', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Set an older version
+      writeTestFile(tempDir, '.safeword/version', '0.0.1');
+
+      await runCli(['upgrade'], { cwd: tempDir });
+
+      const version = readTestFile(tempDir, '.safeword/version').trim();
+      expect(version).not.toBe('0.0.1');
+      expect(version).toMatch(/^\d+\.\d+\.\d+/);
+    });
+  });
+
+  describe('Test 9.2: Updates skills', () => {
+    it('should restore modified skill files', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Find and modify a skill file if it exists
+      if (fileExists(tempDir, '.claude/skills')) {
+        // The actual skill path depends on implementation
+        // This test structure is correct for when skills are implemented
+      }
+
+      const result = await runCli(['upgrade'], { cwd: tempDir });
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('Test 9.3: Preserves non-safeword hooks', () => {
+    it('should preserve custom hooks', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Add a custom hook
+      const settings = JSON.parse(readTestFile(tempDir, '.claude/settings.json'));
+      settings.hooks = settings.hooks || {};
+      settings.hooks.SessionStart = settings.hooks.SessionStart || [];
+      settings.hooks.SessionStart.push({
+        command: 'echo "My custom hook"',
+        description: 'Custom hook',
+      });
+      writeTestFile(tempDir, '.claude/settings.json', JSON.stringify(settings, null, 2));
+
+      await runCli(['upgrade'], { cwd: tempDir });
+
+      const updatedSettings = JSON.parse(readTestFile(tempDir, '.claude/settings.json'));
+      const hasCustomHook = updatedSettings.hooks.SessionStart.some(
+        (hook: { command?: string }) => hook.command === 'echo "My custom hook"',
+      );
+
+      expect(hasCustomHook).toBe(true);
+    });
+  });
+
+  describe('Test 9.4: Same-version reinstalls', () => {
+    it('should restore files even at same version', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Get current version
+      const version = readTestFile(tempDir, '.safeword/version').trim();
+
+      // Modify a file
+      writeTestFile(tempDir, '.safeword/SAFEWORD.md', '# Corrupted\n');
+
+      await runCli(['upgrade'], { cwd: tempDir });
+
+      // File should be restored
+      const content = readTestFile(tempDir, '.safeword/SAFEWORD.md');
+      expect(content).not.toBe('# Corrupted\n');
+
+      // Version should remain same
+      const newVersion = readTestFile(tempDir, '.safeword/version').trim();
+      expect(newVersion).toBe(version);
+    });
+  });
+
+  describe('Test 9.5: Refuses to downgrade', () => {
+    it('should error when project is newer than CLI', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Set a future version
+      writeTestFile(tempDir, '.safeword/version', '99.99.99');
+
+      const result = await runCli(['upgrade'], { cwd: tempDir });
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr.toLowerCase()).toMatch(/older|downgrade|cli|update/i);
+    });
+  });
+
+  describe('Test 9.6: Unconfigured project error', () => {
+    it('should error on unconfigured project', async () => {
+      createTypeScriptPackageJson(tempDir);
+      // No setup
+
+      const result = await runCli(['upgrade'], { cwd: tempDir });
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr.toLowerCase()).toContain('not configured');
+      expect(result.stderr.toLowerCase()).toContain('setup');
+    });
+  });
+
+  describe('Test 9.7: Prints summary of changes', () => {
+    it('should show what changed', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Modify to create changes
+      writeTestFile(tempDir, '.safeword/version', '0.0.1');
+
+      const result = await runCli(['upgrade'], { cwd: tempDir });
+
+      expect(result.exitCode).toBe(0);
+      // Should show some summary of changes
+      expect(result.stdout.toLowerCase()).toMatch(/upgrad|update|version|file/i);
+    });
+  });
+
+  describe('Test 9.8: Preserves learnings directory', () => {
+    it('should preserve user learnings on upgrade', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Create user learning file
+      writeTestFile(
+        tempDir,
+        '.safeword/learnings/my-custom-learning.md',
+        '# My Learning\n\nImportant discovery about the codebase.',
+      );
+
+      // Modify version to trigger upgrade
+      writeTestFile(tempDir, '.safeword/version', '0.0.1');
+
+      await runCli(['upgrade'], { cwd: tempDir });
+
+      // User learning should be preserved
+      expect(fileExists(tempDir, '.safeword/learnings/my-custom-learning.md')).toBe(true);
+
+      const content = readTestFile(tempDir, '.safeword/learnings/my-custom-learning.md');
+      expect(content).toContain('My Learning');
+      expect(content).toContain('Important discovery');
+    });
+  });
+
+  describe('Test 9.9: Creates backup before upgrade', () => {
+    it('should create .safeword.backup directory', async () => {
+      await createConfiguredProject(tempDir);
+
+      // Modify version to trigger upgrade
+      writeTestFile(tempDir, '.safeword/version', '0.0.1');
+
+      // Check for backup during upgrade (it may be deleted after success)
+      // We verify by checking that upgrade succeeds without data loss
+      const originalSafeword = readTestFile(tempDir, '.safeword/SAFEWORD.md');
+
+      await runCli(['upgrade'], { cwd: tempDir });
+
+      // After successful upgrade, backup should be deleted
+      expect(fileExists(tempDir, '.safeword.backup')).toBe(false);
+
+      // Files should still exist
+      expect(fileExists(tempDir, '.safeword/SAFEWORD.md')).toBe(true);
+    });
+  });
+
+  describe('Test 9.10: Restores backup on failure', () => {
+    it.skip('should restore from backup if upgrade fails mid-way', async () => {
+      // This test would require a way to force upgrade failure
+      // Skipped as it requires mocking internal failures
+    });
+  });
+});