safeword 0.2.3 → 0.2.4

package/packages/cli/src/utils/fs.ts

@@ -0,0 +1,179 @@
+/**
+ * File system utilities for CLI operations
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  rmSync,
+  readdirSync,
+  statSync,
+  chmodSync,
+  copyFileSync,
+} from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Get the directory of this module (for locating templates)
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Get path to bundled templates directory.
+ * Works in both development (src/) and production (dist/) contexts.
+ */
+export function getTemplatesDir(): string {
+  // When running from dist/, __dirname is packages/cli/dist/
+  // Templates are at packages/cli/templates/ (one level up)
+  const fromDist = join(__dirname, '..', 'templates');
+
+  // Fallback path for edge cases
+  const fallback = join(__dirname, '..', '..', 'templates');
+
+  if (existsSync(fromDist)) return fromDist;
+  if (existsSync(fallback)) return fallback;
+
+  throw new Error('Templates directory not found');
+}
+
+/**
+ * Check if a path exists
+ */
+export function exists(path: string): boolean {
+  return existsSync(path);
+}
+
+/**
+ * Check if path is a directory
+ */
+export function isDirectory(path: string): boolean {
+  return existsSync(path) && statSync(path).isDirectory();
+}
+
+/**
+ * Create directory recursively
+ */
+export function ensureDir(path: string): void {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+
+/**
+ * Read file as string
+ */
+export function readFile(path: string): string {
+  return readFileSync(path, 'utf-8');
+}
+
+/**
+ * Read file as string, return null if not exists
+ */
+export function readFileSafe(path: string): string | null {
+  if (!existsSync(path)) return null;
+  return readFileSync(path, 'utf-8');
+}
+
+/**
+ * Write file, creating parent directories if needed
+ */
+export function writeFile(path: string, content: string): void {
+  ensureDir(dirname(path));
+  writeFileSync(path, content);
+}
+
+/**
+ * Remove file or directory recursively
+ */
+export function remove(path: string): void {
+  if (existsSync(path)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+}
+
+/**
+ * List files in directory
+ */
+export function listDir(path: string): string[] {
+  if (!existsSync(path)) return [];
+  return readdirSync(path);
+}
+
+/**
+ * Copy a single file
+ */
+export function copyFile(src: string, dest: string): void {
+  ensureDir(dirname(dest));
+  copyFileSync(src, dest);
+}
+
+/**
+ * Copy directory recursively
+ */
+export function copyDir(src: string, dest: string): void {
+  ensureDir(dest);
+  const entries = readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Make file executable
+ */
+export function makeExecutable(path: string): void {
+  chmodSync(path, 0o755);
+}
+
+/**
+ * Make all shell scripts in a directory executable
+ */
+export function makeScriptsExecutable(dirPath: string): void {
+  if (!existsSync(dirPath)) return;
+  for (const file of readdirSync(dirPath)) {
+    if (file.endsWith('.sh')) {
+      chmodSync(join(dirPath, file), 0o755);
+    }
+  }
+}
+
+/**
+ * Read JSON file
+ */
+export function readJson<T = unknown>(path: string): T | null {
+  const content = readFileSafe(path);
+  if (!content) return null;
+  try {
+    return JSON.parse(content) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write JSON file with formatting
+ */
+export function writeJson(path: string, data: unknown): void {
+  writeFile(path, JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Update JSON file, merging with existing content
+ */
+export function updateJson<T extends Record<string, unknown>>(
+  path: string,
+  updater: (existing: T | null) => T,
+): void {
+  const existing = readJson<T>(path);
+  const updated = updater(existing);
+  writeJson(path, updated);
+}

package/packages/cli/src/utils/git.ts

@@ -0,0 +1,124 @@
+/**
+ * Git utilities for CLI operations
+ */
+
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { exists, readFile, writeFile, ensureDir, makeExecutable } from './fs.js';
+
+const MARKER_START = '# SAFEWORD_ARCH_CHECK_START';
+const MARKER_END = '# SAFEWORD_ARCH_CHECK_END';
+
+/**
+ * Check if directory is a git repository
+ */
+export function isGitRepo(cwd: string): boolean {
+  return exists(join(cwd, '.git'));
+}
+
+/**
+ * Initialize a git repository
+ */
+export function initGitRepo(cwd: string): void {
+  execSync('git init', { cwd, stdio: 'pipe' });
+}
+
+/**
+ * Get the pre-commit hook content to add
+ */
+function getHookContent(): string {
+  return `
+${MARKER_START}
+# Safeword architecture check
+# This section is managed by safeword - do not edit manually
+if [ -f ".safeword/hooks/pre-commit.sh" ]; then
+  bash .safeword/hooks/pre-commit.sh
+fi
+${MARKER_END}
+`;
+}
+
+/**
+ * Install safeword markers into pre-commit hook
+ */
+export function installGitHook(cwd: string): void {
+  const hooksDir = join(cwd, '.git', 'hooks');
+  const hookPath = join(hooksDir, 'pre-commit');
+
+  ensureDir(hooksDir);
+
+  let content = '';
+
+  if (exists(hookPath)) {
+    content = readFile(hookPath);
+
+    // Check if already has safeword markers
+    if (content.includes(MARKER_START)) {
+      // Remove existing safeword section and re-add (update)
+      content = removeMarkerSection(content);
+    }
+  } else {
+    // Create new hook file with shebang
+    content = '#!/bin/bash\n';
+  }
+
+  // Add safeword section
+  content = content.trimEnd() + '\n' + getHookContent();
+
+  writeFile(hookPath, content);
+  makeExecutable(hookPath);
+}
+
+/**
+ * Remove safeword markers from pre-commit hook
+ */
+export function removeGitHook(cwd: string): void {
+  const hookPath = join(cwd, '.git', 'hooks', 'pre-commit');
+
+  if (!exists(hookPath)) return;
+
+  let content = readFile(hookPath);
+
+  if (!content.includes(MARKER_START)) return;
+
+  content = removeMarkerSection(content);
+
+  // If only shebang remains, we could delete the file
+  // but safer to leave it
+  writeFile(hookPath, content);
+}
+
+/**
+ * Remove the section between markers (inclusive)
+ */
+function removeMarkerSection(content: string): string {
+  const lines = content.split('\n');
+  const result: string[] = [];
+  let inMarkerSection = false;
+
+  for (const line of lines) {
+    if (line.includes(MARKER_START)) {
+      inMarkerSection = true;
+      continue;
+    }
+    if (line.includes(MARKER_END)) {
+      inMarkerSection = false;
+      continue;
+    }
+    if (!inMarkerSection) {
+      result.push(line);
+    }
+  }
+
+  return result.join('\n').trim() + '\n';
+}
+
+/**
+ * Check if git hooks have safeword markers
+ */
+export function hasGitHook(cwd: string): boolean {
+  const hookPath = join(cwd, '.git', 'hooks', 'pre-commit');
+  if (!exists(hookPath)) return false;
+  const content = readFile(hookPath);
+  return content.includes(MARKER_START);
+}

package/packages/cli/src/utils/hooks.ts

@@ -0,0 +1,29 @@
+/**
+ * Hook utilities for Claude Code settings
+ */
+
+/**
+ * Type guard to check if a value is a hook object with a command property
+ */
+export function isHookObject(h: unknown): h is { command: string } {
+  return (
+    typeof h === 'object' &&
+    h !== null &&
+    'command' in h &&
+    typeof (h as { command: string }).command === 'string'
+  );
+}
+
+/**
+ * Check if a hook is a safeword hook (command contains '.safeword')
+ */
+export function isSafewordHook(h: unknown): boolean {
+  return isHookObject(h) && h.command.includes('.safeword');
+}
+
+/**
+ * Filter out safeword hooks from an array of hooks
+ */
+export function filterOutSafewordHooks(hooks: unknown[]): unknown[] {
+  return hooks.filter((h) => !isSafewordHook(h));
+}

package/packages/cli/src/utils/output.ts

@@ -0,0 +1,60 @@
+/**
+ * Console output utilities for consistent CLI messaging
+ */
+
+/**
+ * Print info message
+ */
+export function info(message: string): void {
+  console.log(message);
+}
+
+/**
+ * Print success message
+ */
+export function success(message: string): void {
+  console.log(`✓ ${message}`);
+}
+
+/**
+ * Print warning message
+ */
+export function warn(message: string): void {
+  console.warn(`⚠ ${message}`);
+}
+
+/**
+ * Print error message to stderr
+ */
+export function error(message: string): void {
+  console.error(`✗ ${message}`);
+}
+
+/**
+ * Print a blank line
+ */
+export function blank(): void {
+  console.log('');
+}
+
+/**
+ * Print a section header
+ */
+export function header(title: string): void {
+  console.log(`\n${title}`);
+  console.log('─'.repeat(title.length));
+}
+
+/**
+ * Print a list item
+ */
+export function listItem(item: string, indent = 2): void {
+  console.log(`${' '.repeat(indent)}• ${item}`);
+}
+
+/**
+ * Print key-value pair
+ */
+export function keyValue(key: string, value: string): void {
+  console.log(`  ${key}: ${value}`);
+}

package/packages/cli/src/utils/project-detector.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Unit tests for project type detection (Tests 4.1-4.3)
+ *
+ * These are pure unit tests for the detectProjectType function.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { detectProjectType, PackageJson } from './project-detector';
+
+describe('detectProjectType', () => {
+  describe('Test 4.1: Detects TypeScript project', () => {
+    it('should detect typescript from devDependencies', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        devDependencies: {
+          typescript: '^5.0.0',
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.typescript).toBe(true);
+    });
+
+    it('should detect typescript from dependencies', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {
+          typescript: '^5.0.0',
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.typescript).toBe(true);
+    });
+
+    it('should return false when typescript is not present', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {},
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.typescript).toBe(false);
+    });
+  });
+
+  describe('Test 4.2: Detects React project', () => {
+    it('should detect react from dependencies', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {
+          react: '^18.0.0',
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.react).toBe(true);
+    });
+
+    it('should detect react from devDependencies', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        devDependencies: {
+          react: '^18.0.0',
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.react).toBe(true);
+    });
+
+    it('should return false when react is not present', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {},
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.react).toBe(false);
+    });
+  });
+
+  describe('Test 4.3: Detects Next.js project', () => {
+    it('should detect next.js from dependencies', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {
+          next: '^14.0.0',
+          react: '^18.0.0',
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.nextjs).toBe(true);
+    });
+
+    it('should imply react when next.js is present', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {
+          next: '^14.0.0',
+          // Note: react not explicitly listed
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.nextjs).toBe(true);
+      expect(result.react).toBe(true); // Next.js implies React
+    });
+  });
+
+  describe('Detects other frameworks', () => {
+    it('should detect Astro project', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        dependencies: {
+          astro: '^4.0.0',
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.astro).toBe(true);
+    });
+
+    it('should detect Electron project', () => {
+      const packageJson: PackageJson = {
+        name: 'test',
+        version: '1.0.0',
+        devDependencies: {
+          electron: '^28.0.0',
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+      expect(result.electron).toBe(true);
+    });
+  });
+
+  describe('Handles edge cases', () => {
+    it('should handle empty package.json', () => {
+      const packageJson: PackageJson = {};
+
+      const result = detectProjectType(packageJson);
+
+      expect(result.typescript).toBe(false);
+      expect(result.react).toBe(false);
+      expect(result.nextjs).toBe(false);
+      expect(result.astro).toBe(false);
+      expect(result.electron).toBe(false);
+    });
+
+    it('should handle complex project with multiple frameworks', () => {
+      const packageJson: PackageJson = {
+        name: 'complex-project',
+        version: '1.0.0',
+        dependencies: {
+          next: '^14.0.0',
+          react: '^18.0.0',
+          'react-dom': '^18.0.0',
+        },
+        devDependencies: {
+          typescript: '^5.3.0',
+          electron: '^28.0.0',
+        },
+      };
+
+      const result = detectProjectType(packageJson);
+
+      expect(result.typescript).toBe(true);
+      expect(result.react).toBe(true);
+      expect(result.nextjs).toBe(true);
+      expect(result.electron).toBe(true);
+      expect(result.astro).toBe(false);
+    });
+  });
+});

package/packages/cli/src/utils/project-detector.ts

@@ -0,0 +1,44 @@
+/**
+ * Project type detection from package.json
+ *
+ * Detects frameworks and tools used in the project to configure
+ * appropriate linting rules.
+ */
+
+export interface PackageJson {
+  name?: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+export interface ProjectType {
+  typescript: boolean;
+  react: boolean;
+  nextjs: boolean;
+  astro: boolean;
+  electron: boolean;
+}
+
+/**
+ * Detects project type from package.json contents
+ */
+export function detectProjectType(packageJson: PackageJson): ProjectType {
+  const deps = packageJson.dependencies || {};
+  const devDeps = packageJson.devDependencies || {};
+  const allDeps = { ...deps, ...devDeps };
+
+  const hasTypescript = 'typescript' in allDeps;
+  const hasReact = 'react' in deps || 'react' in devDeps;
+  const hasNextJs = 'next' in deps;
+  const hasAstro = 'astro' in deps || 'astro' in devDeps;
+  const hasElectron = 'electron' in deps || 'electron' in devDeps;
+
+  return {
+    typescript: hasTypescript,
+    react: hasReact || hasNextJs, // Next.js implies React
+    nextjs: hasNextJs,
+    astro: hasAstro,
+    electron: hasElectron,
+  };
+}

package/packages/cli/src/utils/version.ts

@@ -0,0 +1,28 @@
+/**
+ * Version comparison utilities
+ */
+
+/**
+ * Compare two semver versions
+ * @returns -1 if a < b, 0 if a == b, 1 if a > b
+ */
+export function compareVersions(a: string, b: string): -1 | 0 | 1 {
+  const aParts = a.split('.').map(Number);
+  const bParts = b.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const aVal = aParts[i] ?? 0;
+    const bVal = bParts[i] ?? 0;
+    if (aVal < bVal) return -1;
+    if (aVal > bVal) return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * Check if latest version is newer than current
+ */
+export function isNewerVersion(current: string, latest: string): boolean {
+  return compareVersions(current, latest) === -1;
+}

package/packages/cli/src/version.ts

@@ -0,0 +1,6 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json') as { version: string };
+
+export const VERSION = pkg.version;