spck 0.3.1

package/src/utils/project-dir.ts

@@ -0,0 +1,218 @@
+/**
+ * Project directory management with symlink support
+ * .spck-editor/ is a regular directory with .spck-editor/config symlinked to ~/.spck-editor/projects/{id}
+ * This prevents accidental git commits of secrets while avoiding cross-device link errors
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+import { t } from '../i18n/index.js';
+
+const PROJECT_DIR_NAME = '.spck-editor';
+const CONFIG_SUBDIR_NAME = 'config';
+
+/**
+ * Get the home base directory for projects
+ * Called at runtime instead of module load time to avoid issues in test environments
+ */
+function getHomeBaseDir(): string {
+  return path.join(os.homedir(), '.spck-editor', 'projects');
+}
+
+/**
+ * Generate a consistent project ID from the project root path
+ */
+export function generateProjectId(projectRoot: string): string {
+  // Resolve to absolute path and normalize
+  const absolutePath = path.resolve(projectRoot);
+
+  // Generate SHA256 hash of the absolute path
+  const hash = crypto.createHash('sha256').update(absolutePath).digest('hex');
+
+  // Use first 16 characters for readability (still unique enough)
+  return hash.substring(0, 16);
+}
+
+/**
+ * Get the home directory location for a project's data
+ */
+export function getProjectDataPath(projectRoot: string): string {
+  const projectId = generateProjectId(projectRoot);
+  return path.join(getHomeBaseDir(), projectId);
+}
+
+/**
+ * Get the .spck-editor directory path in the project
+ */
+export function getProjectDirPath(projectRoot: string): string {
+  return path.join(projectRoot, PROJECT_DIR_NAME);
+}
+
+/**
+ * Get the config symlink path (.spck-editor/config)
+ */
+export function getConfigSymlinkPath(projectRoot: string): string {
+  return path.join(projectRoot, PROJECT_DIR_NAME, CONFIG_SUBDIR_NAME);
+}
+
+/**
+ * @deprecated Use getConfigSymlinkPath() instead
+ * Legacy compatibility - returns config symlink path
+ */
+export function getProjectSymlinkPath(projectRoot: string): string {
+  return getConfigSymlinkPath(projectRoot);
+}
+
+/**
+ * Check if the project directory exists and is properly set up
+ */
+export function isProjectDirSetup(projectRoot: string): boolean {
+  const projectDir = getProjectDirPath(projectRoot);
+  const configSymlink = getConfigSymlinkPath(projectRoot);
+  const dataPath = getProjectDataPath(projectRoot);
+
+  // Check if .spck-editor directory exists
+  if (!fs.existsSync(projectDir)) {
+    return false;
+  }
+
+  // Check if .spck-editor is a directory (not old-style symlink)
+  try {
+    const stats = fs.lstatSync(projectDir);
+    if (stats.isSymbolicLink()) {
+      // Old structure - needs migration
+      return false;
+    }
+    if (!stats.isDirectory()) {
+      return false;
+    }
+  } catch (error) {
+    return false;
+  }
+
+  // Check if config symlink exists
+  if (!fs.existsSync(configSymlink)) {
+    return false;
+  }
+
+  // Check if config is a symlink
+  try {
+    const stats = fs.lstatSync(configSymlink);
+    if (!stats.isSymbolicLink()) {
+      return false;
+    }
+  } catch (error) {
+    return false;
+  }
+
+  // Check if data directory exists
+  if (!fs.existsSync(dataPath)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Setup the project directory with config symlink
+ * Creates ~/.spck-editor/projects/{project_id}/ and symlinks .spck-editor/config to it
+ */
+export function setupProjectDir(projectRoot: string): void {
+  const projectDir = getProjectDirPath(projectRoot);
+  const configSymlink = getConfigSymlinkPath(projectRoot);
+  const dataPath = getProjectDataPath(projectRoot);
+  const homeBaseDir = getHomeBaseDir();
+
+  // Ensure home base directory exists
+  if (!fs.existsSync(homeBaseDir)) {
+    fs.mkdirSync(homeBaseDir, { recursive: true, mode: 0o700 });
+  }
+
+  // Ensure project data directory exists
+  if (!fs.existsSync(dataPath)) {
+    fs.mkdirSync(dataPath, { recursive: true, mode: 0o700 });
+  }
+
+  // Create .spck-editor directory if it doesn't exist
+  if (!fs.existsSync(projectDir)) {
+    fs.mkdirSync(projectDir, { mode: 0o700 });
+  }
+
+  // Create subdirectories (.tmp, .trash, logs)
+  const subdirs = ['.tmp', '.trash', 'logs'];
+  for (const subdir of subdirs) {
+    const subdirPath = path.join(projectDir, subdir);
+    if (!fs.existsSync(subdirPath)) {
+      fs.mkdirSync(subdirPath, { mode: 0o700 });
+    }
+  }
+
+  // Create config symlink if it doesn't exist
+  if (!fs.existsSync(configSymlink)) {
+    fs.symlinkSync(dataPath, configSymlink, 'dir');
+  } else {
+    // Verify existing symlink points to correct location
+    const stats = fs.lstatSync(configSymlink);
+    if (stats.isSymbolicLink()) {
+      const target = fs.readlinkSync(configSymlink);
+      if (target !== dataPath) {
+        // Points to wrong location - remove and recreate
+        fs.unlinkSync(configSymlink);
+        fs.symlinkSync(dataPath, configSymlink, 'dir');
+      }
+    }
+  }
+
+  console.log(`✅ ${t('projectDir.configured')}`);
+  console.log(`   ${t('projectDir.directory', { path: projectDir })}`);
+  console.log(`   ${t('projectDir.configLink', { symlink: configSymlink, dataPath })}\n`);
+}
+
+/**
+ * Ensure project directory is set up, creating if needed
+ */
+export function ensureProjectDir(projectRoot: string): void {
+  if (!isProjectDirSetup(projectRoot)) {
+    setupProjectDir(projectRoot);
+  }
+}
+
+/**
+ * Get the absolute path to a file within the project directory
+ * Files go in .spck-editor/{filename} (local) or .spck-editor/config/{filename} (symlinked)
+ * Config files (like connection-settings.json) go in the config subdirectory
+ */
+export function getProjectFilePath(projectRoot: string, filename: string): string {
+  const projectDir = getProjectDirPath(projectRoot);
+
+  // Config files go in the symlinked config directory
+  const configFiles = ['connection-settings.json', '.credentials.json', 'spck-cli.config.json'];
+  if (configFiles.includes(filename)) {
+    const configSymlink = getConfigSymlinkPath(projectRoot);
+    return path.join(configSymlink, filename);
+  }
+
+  // All other files go in the local .spck-editor directory
+  return path.join(projectDir, filename);
+}
+
+/**
+ * Remove project directory and all associated data
+ * WARNING: This deletes the data directory in home and the local .spck-editor directory
+ */
+export function removeProjectDir(projectRoot: string): void {
+  const projectDir = getProjectDirPath(projectRoot);
+  const dataPath = getProjectDataPath(projectRoot);
+
+  // Remove .spck-editor directory if exists (includes config symlink and local files)
+  if (fs.existsSync(projectDir)) {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  }
+
+  // Remove data directory in home if exists
+  if (fs.existsSync(dataPath)) {
+    fs.rmSync(dataPath, { recursive: true, force: true });
+  }
+}

package/src/utils/ripgrep.ts

@@ -0,0 +1,180 @@
+/**
+ * Ripgrep wrapper utility
+ *
+ * Uses system-installed ripgrep (rg) if available
+ */
+
+import { spawn } from 'child_process';
+
+/**
+ * Get the ripgrep command name for the current platform
+ */
+export function getRipgrepCommand(): string {
+  // On Windows, try both 'rg.exe' and 'rg'
+  // On Unix-like systems, use 'rg'
+  return process.platform === 'win32' ? 'rg.exe' : 'rg';
+}
+
+/**
+ * Check if ripgrep is available on the system PATH
+ */
+export async function isRipgrepAvailable(): Promise<boolean> {
+  const rgCommand = getRipgrepCommand();
+
+  // Try to execute ripgrep --version to verify it works
+  return new Promise((resolve) => {
+    try {
+      const proc = spawn(rgCommand, ['--version'], {
+        cwd: process.cwd(),
+        stdio: 'ignore',
+        shell: false
+      });
+
+      proc.on('error', () => resolve(false));
+      proc.on('close', (code) => resolve(code === 0));
+    } catch (err) {
+      resolve(false)
+    }
+  });
+}
+
+/**
+ * Execute ripgrep search (buffered - waits for completion)
+ */
+export async function executeRipgrep(
+  path: string,
+  args: string[],
+  options?: {
+    timeout?: number;
+  }
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const rgCommand = getRipgrepCommand();
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(rgCommand, args, {
+      cwd: path,
+      stdio: 'pipe',
+      shell: false
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+
+    // Set timeout if specified
+    const timeout = options?.timeout;
+    let timeoutId: NodeJS.Timeout | undefined;
+    if (timeout) {
+      timeoutId = setTimeout(() => {
+        killed = true;
+        proc.kill();
+        reject(new Error(`Ripgrep execution timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('error', (error) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (!killed) {
+        reject(error);
+      }
+    });
+
+    proc.on('close', (code) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (!killed) {
+        resolve({
+          stdout,
+          stderr,
+          exitCode: code ?? -1
+        });
+      }
+    });
+  });
+}
+
+/**
+ * Execute ripgrep search with streaming output
+ * Calls onLine for each line of output as it arrives
+ */
+export async function executeRipgrepStream(
+  path: string,
+  args: string[],
+  options: {
+    timeout?: number;
+    onLine: (line: string) => void;
+  }
+): Promise<{ exitCode: number }> {
+  const rgCommand = getRipgrepCommand();
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(rgCommand, args, {
+      cwd: path,
+      stdio: 'pipe',
+      shell: false
+    });
+
+    let killed = false;
+    let buffer = '';
+
+    // Set timeout if specified
+    const timeout = options.timeout;
+    let timeoutId: NodeJS.Timeout | undefined;
+    if (timeout) {
+      timeoutId = setTimeout(() => {
+        killed = true;
+        proc.kill();
+        reject(new Error(`Ripgrep execution timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    // Process stdout line by line as it arrives
+    proc.stdout?.on('data', (data) => {
+      buffer += data.toString();
+      const lines = buffer.split('\n');
+
+      // Keep the last incomplete line in the buffer
+      buffer = lines.pop() || '';
+
+      // Process complete lines
+      for (const line of lines) {
+        if (line.trim()) {
+          options.onLine(line);
+        }
+      }
+    });
+
+    proc.stderr?.on('data', (_data) => {
+      // Ignore stderr for now
+    });
+
+    proc.on('error', (error) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (!killed) {
+        reject(error);
+      }
+    });
+
+    proc.on('close', (code) => {
+      if (timeoutId) clearTimeout(timeoutId);
+
+      // Process any remaining buffered data
+      if (buffer.trim()) {
+        options.onLine(buffer);
+      }
+
+      if (!killed) {
+        resolve({
+          exitCode: code ?? -1
+        });
+      }
+    });
+  });
+}

package/src/utils/tool-detection.ts

@@ -0,0 +1,141 @@
+/**
+ * Tool detection for git and ripgrep
+ * Checks if required tools are installed and displays warnings
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { ToolDetectionResult } from '../types.js';
+import { t } from '../i18n/index.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if a command is available
+ */
+async function isCommandAvailable(command: string): Promise<boolean> {
+  try {
+    await execAsync(`${command} --version`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Detect available tools (git and ripgrep)
+ */
+export async function detectTools(options?: {
+  disableGit?: boolean;
+  disableRipgrep?: boolean;
+}): Promise<ToolDetectionResult> {
+  console.log(`\n=== ${t('tools.title')} ===\n`);
+
+  const result: ToolDetectionResult = {
+    git: false,
+    ripgrep: false
+  };
+
+  // Check Git (unless force-disabled for development)
+  if (options?.disableGit) {
+    console.log(`⚠️  ${t('tools.gitForceDisabled')}`);
+  } else {
+    result.git = await isCommandAvailable('git');
+
+    if (result.git) {
+      try {
+        const { stdout } = await execAsync('git --version');
+        console.log(`✅ ${t('tools.gitDetected', { version: stdout.trim() })}`);
+      } catch {
+        console.log(`✅ ${t('tools.gitDetectedShort')}`);
+      }
+    } else {
+      console.warn(`⚠️  ${t('tools.gitNotDetected')}`);
+      console.warn(`   ${t('tools.gitDisabledHint')}`);
+      console.warn(`   ${t('tools.gitInstallHint')}`);
+      console.warn(`   ${t('tools.gitInstallUrl')}\n`);
+    }
+  }
+
+  // Check Ripgrep (unless force-disabled for development)
+  if (options?.disableRipgrep) {
+    console.log(`⚠️  ${t('tools.ripgrepForceDisabled')}`);
+  } else {
+    result.ripgrep = await isCommandAvailable('rg');
+
+    if (result.ripgrep) {
+      try {
+        const { stdout } = await execAsync('rg --version');
+        const firstLine = stdout.split('\n')[0];
+        console.log(`✅ ${t('tools.ripgrepDetected', { version: firstLine })}`);
+      } catch {
+        console.log(`✅ ${t('tools.ripgrepDetectedShort')}`);
+      }
+    } else {
+      console.warn(`⚠️  ${t('tools.ripgrepNotDetected')}`);
+      console.warn(`   ${t('tools.ripgrepDisabledHint')}`);
+      console.warn(`   ${t('tools.ripgrepInstallHint')}`);
+      console.warn(`   ${t('tools.ripgrepInstallUrl')}\n`);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Display feature summary based on detected tools
+ */
+export function displayFeatureSummary(
+  tools: ToolDetectionResult,
+  terminalEnabled: boolean,
+  userAuthEnabled?: boolean,
+  browserProxyEnabled?: boolean
+): void {
+  console.log(`\n=== ${t('features.title')} ===\n`);
+
+  const features: string[] = [];
+
+  // Always available
+  features.push(`✅ ${t('features.filesystem')}`);
+
+  // Conditional features
+  if (tools.git) {
+    features.push(`✅ ${t('features.gitEnabled')}`);
+  } else {
+    features.push(`❌ ${t('features.gitDisabled')}`);
+  }
+
+  if (tools.ripgrep) {
+    features.push(`✅ ${t('features.searchFast')}`);
+  } else {
+    features.push(`⚠️  ${t('features.searchBasic')}`);
+  }
+
+  if (terminalEnabled) {
+    features.push(`✅ ${t('features.terminalEnabled')}`);
+  } else {
+    features.push(`❌ ${t('features.terminalDisabled')}`);
+  }
+
+  if (browserProxyEnabled !== false) {
+    features.push(`✅ ${t('features.browserProxyEnabled')}`);
+  } else {
+    features.push(`❌ ${t('features.browserProxyDisabled')}`);
+  }
+
+  features.forEach(feature => console.log(`   ${feature}`));
+
+  // Display authentication mode
+  console.log(`\n=== ${t('features.securityTitle')} ===\n`);
+  if (userAuthEnabled) {
+    console.log(`   🔐 ${t('features.userAuthEnabled')}`);
+    console.log(`   → ${t('features.userAuthEnabledHint1')}`);
+    console.log(`   → ${t('features.userAuthEnabledHint2')}`);
+    console.log(`   → ${t('features.userAuthEnabledHint3')}\n`);
+  } else {
+    console.log(`   🔓 ${t('features.userAuthDisabled')}`);
+    console.log(`   → ${t('features.userAuthDisabledHint1')}`);
+    console.log(`   → ${t('features.userAuthDisabledHint2')}`);
+    console.log(`   → ${t('features.userAuthDisabledHint3')}\n`);
+  }
+}

package/src/watcher/FileWatcher.ts

@@ -0,0 +1,53 @@
+/**
+ * File system watcher using chokidar
+ */
+
+import * as chokidar from 'chokidar';
+import { EventEmitter } from 'events';
+
+export class FileWatcher extends EventEmitter {
+  private watcher: chokidar.FSWatcher;
+
+  constructor(rootPath: string, ignorePatterns: string[]) {
+    super();
+
+    this.watcher = chokidar.watch(rootPath, {
+      ignored: ignorePatterns,
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50,
+      },
+    });
+
+    this.watcher.on('change', (path, stats) => {
+      this.emit('change', path, stats?.mtimeMs);
+    });
+
+    this.watcher.on('unlink', (path) => {
+      this.emit('removed', path);
+    });
+
+    this.watcher.on('add', (path, stats) => {
+      this.emit('added', path, stats?.mtimeMs);
+    });
+
+    this.watcher.on('unlinkDir', (path) => {
+      this.emit('removed', path);
+    });
+
+    this.watcher.on('addDir', (path) => {
+      this.emit('added', path);
+    });
+
+    this.watcher.on('error', (error) => {
+      console.error('File watcher error:', error);
+      this.emit('error', error);
+    });
+  }
+
+  close(): void {
+    this.watcher.close();
+  }
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "ES2020",
+    "lib": ["ES2021"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "types": []
+  },
+  "include": ["src/**/*"],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+    testTimeout: 10000,
+    server: {
+      deps: {
+        inline: ['default-shell', 'os-locale'],
+      },
+    },
+    coverage: {
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/*.d.ts', 'src/**/__tests__/**'],
+      reportsDirectory: 'coverage',
+      reporter: ['text', 'lcov', 'html'],
+    },
+  },
+});