cluttry 1.0.0

package/tests/paths.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Unit tests for path utilities
+ */
+
+import { describe, it, expect } from 'vitest';
+import { sanitizeBranchName, getDefaultWorktreePath, resolveBranchOrPath } from '../src/lib/paths.js';
+
+describe('sanitizeBranchName', () => {
+  it('replaces forward slashes with dashes', () => {
+    // Slashes become dashes (collapsed from double-dashes)
+    expect(sanitizeBranchName('feature/add-login')).toBe('feature-add-login');
+    expect(sanitizeBranchName('fix/bug/123')).toBe('fix-bug-123');
+  });
+
+  it('replaces Windows-forbidden characters', () => {
+    expect(sanitizeBranchName('test<>:"|?*\\')).toBe('test');
+    expect(sanitizeBranchName('branch:name')).toBe('branch-name');
+  });
+
+  it('replaces whitespace with dashes', () => {
+    expect(sanitizeBranchName('my branch name')).toBe('my-branch-name');
+    expect(sanitizeBranchName('tabs\there')).toBe('tabs-here');
+  });
+
+  it('removes leading and trailing dots', () => {
+    expect(sanitizeBranchName('.hidden')).toBe('hidden');
+    expect(sanitizeBranchName('trailing.')).toBe('trailing');
+    expect(sanitizeBranchName('...dots...')).toBe('dots');
+  });
+
+  it('collapses multiple dashes', () => {
+    expect(sanitizeBranchName('a--b---c')).toBe('a-b-c');
+  });
+
+  it('removes leading and trailing dashes', () => {
+    expect(sanitizeBranchName('-start')).toBe('start');
+    expect(sanitizeBranchName('end-')).toBe('end');
+    expect(sanitizeBranchName('---middle---')).toBe('middle');
+  });
+
+  it('handles complex branch names', () => {
+    expect(sanitizeBranchName('feature/user-auth/oauth2.0')).toBe('feature-user-auth-oauth2.0');
+    // Note: # is allowed in branch names and preserved
+    expect(sanitizeBranchName('fix/issue#123')).toBe('fix-issue#123');
+  });
+
+  it('handles simple branch names unchanged', () => {
+    expect(sanitizeBranchName('main')).toBe('main');
+    expect(sanitizeBranchName('develop')).toBe('develop');
+    expect(sanitizeBranchName('my-feature')).toBe('my-feature');
+  });
+});
+
+describe('getDefaultWorktreePath', () => {
+  const repoRoot = '/home/user/myrepo';
+
+  it('returns explicit path when provided', () => {
+    const result = getDefaultWorktreePath(repoRoot, 'feature', {
+      explicitPath: '/custom/path',
+    });
+    expect(result).toBe('/custom/path');
+  });
+
+  it('resolves relative explicit path against CWD', () => {
+    const result = getDefaultWorktreePath(repoRoot, 'feature', {
+      explicitPath: './relative/path',
+    });
+    expect(result).toContain('relative/path');
+  });
+
+  it('uses base directory with repo name and sanitized branch', () => {
+    const result = getDefaultWorktreePath(repoRoot, 'feature/test', {
+      baseDir: '/worktrees',
+      repoName: 'myrepo',
+    });
+    expect(result).toBe('/worktrees/myrepo/feature-test');
+  });
+
+  it('derives repo name from repoRoot if not provided', () => {
+    const result = getDefaultWorktreePath(repoRoot, 'main', {
+      baseDir: '/worktrees',
+    });
+    expect(result).toBe('/worktrees/myrepo/main');
+  });
+
+  it('resolves relative base directory against repo root', () => {
+    const result = getDefaultWorktreePath(repoRoot, 'feature', {
+      baseDir: '../sibling',
+      repoName: 'myrepo',
+    });
+    expect(result).toContain('myrepo/feature');
+  });
+
+  it('defaults to .worktrees/<branch> inside repo', () => {
+    const result = getDefaultWorktreePath(repoRoot, 'my-branch');
+    expect(result).toBe('/home/user/myrepo/.worktrees/my-branch');
+  });
+
+  it('sanitizes branch names in default path', () => {
+    const result = getDefaultWorktreePath(repoRoot, 'feature/login');
+    expect(result).toBe('/home/user/myrepo/.worktrees/feature-login');
+  });
+});
+
+describe('resolveBranchOrPath', () => {
+  const repoRoot = '/home/user/myrepo';
+  const worktrees = [
+    { branch: 'main', path: '/home/user/myrepo' },
+    { branch: 'feature-login', path: '/home/user/myrepo/.worktrees/feature-login' },
+    { branch: null, path: '/home/user/myrepo/.worktrees/detached' },
+  ];
+
+  it('finds worktree by exact branch name', () => {
+    const result = resolveBranchOrPath('feature-login', worktrees, repoRoot);
+    expect(result).toEqual({
+      branch: 'feature-login',
+      path: '/home/user/myrepo/.worktrees/feature-login',
+    });
+  });
+
+  it('finds worktree by absolute path', () => {
+    const result = resolveBranchOrPath('/home/user/myrepo/.worktrees/feature-login', worktrees, repoRoot);
+    expect(result).toEqual({
+      branch: 'feature-login',
+      path: '/home/user/myrepo/.worktrees/feature-login',
+    });
+  });
+
+  it('finds worktree by partial path suffix', () => {
+    const result = resolveBranchOrPath('feature-login', worktrees, repoRoot);
+    expect(result).not.toBeNull();
+    expect(result?.branch).toBe('feature-login');
+  });
+
+  it('returns null when no match found', () => {
+    const result = resolveBranchOrPath('nonexistent', worktrees, repoRoot);
+    expect(result).toBeNull();
+  });
+
+  it('handles detached worktrees', () => {
+    const result = resolveBranchOrPath('/home/user/myrepo/.worktrees/detached', worktrees, repoRoot);
+    expect(result).toEqual({
+      branch: null,
+      path: '/home/user/myrepo/.worktrees/detached',
+    });
+  });
+
+  it('handles main worktree', () => {
+    const result = resolveBranchOrPath('main', worktrees, repoRoot);
+    expect(result).toEqual({
+      branch: 'main',
+      path: '/home/user/myrepo',
+    });
+  });
+});

package/tests/secrets.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Unit tests for secrets/file safety module
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { checkFileSafety } from '../src/lib/secrets.js';
+import * as fs from 'node:fs';
+import * as git from '../src/lib/git.js';
+
+// Mock the modules
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  copyFileSync: vi.fn(),
+  symlinkSync: vi.fn(),
+  mkdirSync: vi.fn(),
+  statSync: vi.fn(),
+  readdirSync: vi.fn(),
+}));
+
+vi.mock('../src/lib/git.js', () => ({
+  isTracked: vi.fn(),
+  isIgnored: vi.fn(),
+}));
+
+describe('checkFileSafety', () => {
+  const repoRoot = '/home/user/myrepo';
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns unsafe result when file does not exist', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    const result = checkFileSafety('.env', repoRoot);
+
+    expect(result.safe).toBe(false);
+    expect(result.exists).toBe(false);
+    expect(result.reason).toBe('File does not exist');
+  });
+
+  it('returns unsafe result when file is tracked by git', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(git.isTracked).mockReturnValue(true);
+
+    const result = checkFileSafety('.env', repoRoot);
+
+    expect(result.safe).toBe(false);
+    expect(result.exists).toBe(true);
+    expect(result.isTracked).toBe(true);
+    expect(result.reason).toBe('File is tracked by git (would be committed)');
+  });
+
+  it('returns unsafe result when file is not ignored by git', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(git.isTracked).mockReturnValue(false);
+    vi.mocked(git.isIgnored).mockReturnValue(false);
+
+    const result = checkFileSafety('.env', repoRoot);
+
+    expect(result.safe).toBe(false);
+    expect(result.exists).toBe(true);
+    expect(result.isTracked).toBe(false);
+    expect(result.isIgnored).toBe(false);
+    expect(result.reason).toBe('File is not ignored by git (could be accidentally committed)');
+  });
+
+  it('returns safe result when file exists, is not tracked, and is ignored', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(git.isTracked).mockReturnValue(false);
+    vi.mocked(git.isIgnored).mockReturnValue(true);
+
+    const result = checkFileSafety('.env', repoRoot);
+
+    expect(result.safe).toBe(true);
+    expect(result.exists).toBe(true);
+    expect(result.isTracked).toBe(false);
+    expect(result.isIgnored).toBe(true);
+    expect(result.reason).toBeUndefined();
+  });
+
+  it('handles absolute paths correctly', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(git.isTracked).mockReturnValue(false);
+    vi.mocked(git.isIgnored).mockReturnValue(true);
+
+    const result = checkFileSafety('/home/user/myrepo/.env', repoRoot);
+
+    expect(result.path).toBe('.env');
+    expect(result.safe).toBe(true);
+  });
+
+  it('handles nested paths correctly', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(git.isTracked).mockReturnValue(false);
+    vi.mocked(git.isIgnored).mockReturnValue(true);
+
+    const result = checkFileSafety('config/secrets/oauth.json', repoRoot);
+
+    expect(result.path).toBe('config/secrets/oauth.json');
+    expect(result.safe).toBe(true);
+  });
+});
+
+describe('safety enforcement rules', () => {
+  const repoRoot = '/home/user/myrepo';
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('NEVER allows tracked files to be copied/symlinked', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(git.isTracked).mockReturnValue(true);
+    vi.mocked(git.isIgnored).mockReturnValue(false); // Even if somehow ignored
+
+    const result = checkFileSafety('src/config.ts', repoRoot);
+
+    expect(result.safe).toBe(false);
+    expect(result.reason).toContain('tracked');
+  });
+
+  it('ONLY allows files that are explicitly ignored', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(git.isTracked).mockReturnValue(false);
+    vi.mocked(git.isIgnored).mockReturnValue(false);
+
+    const result = checkFileSafety('random-file.txt', repoRoot);
+
+    expect(result.safe).toBe(false);
+    expect(result.reason).toContain('not ignored');
+  });
+
+  it('correctly identifies safe secret files', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(git.isTracked).mockReturnValue(false);
+    vi.mocked(git.isIgnored).mockReturnValue(true);
+
+    const secretFiles = ['.env', '.env.local', 'config/oauth.json', '.secrets/api-key'];
+
+    for (const file of secretFiles) {
+      const result = checkFileSafety(file, repoRoot);
+      expect(result.safe).toBe(true);
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: ['src/**/*.ts'],
+      exclude: ['src/index.ts'],
+    },
+  },
+});