claudehq 1.0.3 → 1.0.5

package/lib/spawner/projects-manager.js

@@ -0,0 +1,421 @@
+/**
+ * Projects Manager - Track and manage known project directories
+ *
+ * Provides autocomplete functionality for directory paths and
+ * tracks recently used directories for quick access.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { validateDirectoryPath, normalizePath } = require('./path-validator');
+
+// Default data directory
+const DEFAULT_DATA_DIR = path.join(os.homedir(), '.claude', 'tasks-board');
+const DEFAULT_PROJECTS_FILE = path.join(DEFAULT_DATA_DIR, 'projects.json');
+
+// Maximum number of projects to track
+const MAX_TRACKED_PROJECTS = 100;
+
+// Maximum autocomplete results
+const MAX_AUTOCOMPLETE_RESULTS = 15;
+
+/**
+ * Create a projects manager instance
+ * @param {Object} options - Configuration options
+ * @param {string} options.dataDir - Directory for data storage
+ * @param {string} options.projectsFile - Path to projects JSON file
+ * @returns {Object} Projects manager instance
+ */
+function createProjectsManager(options = {}) {
+  const dataDir = options.dataDir || DEFAULT_DATA_DIR;
+  const projectsFile = options.projectsFile || DEFAULT_PROJECTS_FILE;
+
+  // In-memory cache of projects
+  let projects = new Map();
+
+  /**
+   * Ensure data directory exists
+   */
+  function ensureDataDir() {
+    if (!fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Load projects from disk
+   */
+  function loadProjects() {
+    try {
+      if (fs.existsSync(projectsFile)) {
+        const content = fs.readFileSync(projectsFile, 'utf-8');
+        const data = JSON.parse(content);
+
+        projects.clear();
+        if (Array.isArray(data.projects)) {
+          for (const p of data.projects) {
+            projects.set(p.path, {
+              path: p.path,
+              name: p.name || path.basename(p.path),
+              lastUsed: p.lastUsed || Date.now(),
+              useCount: p.useCount || 1,
+              addedAt: p.addedAt || Date.now()
+            });
+          }
+        }
+      }
+    } catch (e) {
+      console.error('Error loading projects:', e.message);
+      projects.clear();
+    }
+  }
+
+  /**
+   * Save projects to disk
+   */
+  function saveProjects() {
+    try {
+      ensureDataDir();
+
+      // Convert to array and sort by lastUsed
+      const projectsArray = Array.from(projects.values())
+        .sort((a, b) => b.lastUsed - a.lastUsed)
+        .slice(0, MAX_TRACKED_PROJECTS);
+
+      fs.writeFileSync(projectsFile, JSON.stringify({
+        version: 1,
+        updatedAt: new Date().toISOString(),
+        projects: projectsArray
+      }, null, 2));
+    } catch (e) {
+      console.error('Error saving projects:', e.message);
+    }
+  }
+
+  /**
+   * Track a project directory
+   * @param {string} dirPath - Directory path to track
+   * @param {string} name - Optional display name
+   * @returns {Object} Result { success: boolean, project: object, error: string }
+   */
+  function trackProject(dirPath, name = null) {
+    const validation = validateDirectoryPath(dirPath);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+
+    const normalizedPath = validation.path;
+    const existing = projects.get(normalizedPath);
+
+    if (existing) {
+      // Update existing project
+      existing.lastUsed = Date.now();
+      existing.useCount++;
+      if (name) {
+        existing.name = name;
+      }
+      saveProjects();
+      return { success: true, project: existing };
+    }
+
+    // Add new project
+    const project = {
+      path: normalizedPath,
+      name: name || path.basename(normalizedPath),
+      lastUsed: Date.now(),
+      useCount: 1,
+      addedAt: Date.now()
+    };
+
+    projects.set(normalizedPath, project);
+
+    // Trim if over limit
+    if (projects.size > MAX_TRACKED_PROJECTS) {
+      const sorted = Array.from(projects.entries())
+        .sort((a, b) => b[1].lastUsed - a[1].lastUsed);
+      projects = new Map(sorted.slice(0, MAX_TRACKED_PROJECTS));
+    }
+
+    saveProjects();
+    return { success: true, project };
+  }
+
+  /**
+   * Get a tracked project by path
+   * @param {string} dirPath - Directory path
+   * @returns {Object|null} Project or null
+   */
+  function getProject(dirPath) {
+    const normalized = normalizePath(dirPath);
+    return projects.get(normalized) || null;
+  }
+
+  /**
+   * List all tracked projects
+   * @param {Object} options - List options
+   * @param {number} options.limit - Max results (default: all)
+   * @param {string} options.sortBy - Sort field: 'lastUsed', 'useCount', 'name' (default: 'lastUsed')
+   * @returns {Array} Array of project objects
+   */
+  function listProjects(options = {}) {
+    const { limit, sortBy = 'lastUsed' } = options;
+
+    let result = Array.from(projects.values());
+
+    // Sort
+    switch (sortBy) {
+      case 'useCount':
+        result.sort((a, b) => b.useCount - a.useCount);
+        break;
+      case 'name':
+        result.sort((a, b) => a.name.localeCompare(b.name));
+        break;
+      case 'lastUsed':
+      default:
+        result.sort((a, b) => b.lastUsed - a.lastUsed);
+    }
+
+    if (limit && limit > 0) {
+      result = result.slice(0, limit);
+    }
+
+    return result;
+  }
+
+  /**
+   * Remove a tracked project
+   * @param {string} dirPath - Directory path
+   * @returns {Object} Result { success: boolean }
+   */
+  function removeProject(dirPath) {
+    const normalized = normalizePath(dirPath);
+    const existed = projects.delete(normalized);
+    if (existed) {
+      saveProjects();
+    }
+    return { success: existed };
+  }
+
+  /**
+   * Get filesystem directory completions
+   * @param {string} partial - Partial path to complete
+   * @returns {Array} Array of directory paths
+   */
+  function getFilesystemCompletions(partial) {
+    if (!partial) {
+      return [];
+    }
+
+    const results = [];
+    let searchDir;
+    let prefix = '';
+
+    const normalized = normalizePath(partial);
+
+    try {
+      const stats = fs.statSync(normalized);
+      if (stats.isDirectory()) {
+        // If the path is a complete directory, list its contents
+        searchDir = normalized;
+        prefix = '';
+      }
+    } catch (e) {
+      // Path doesn't exist as-is, look for completions
+      searchDir = path.dirname(normalized);
+      prefix = path.basename(normalized).toLowerCase();
+    }
+
+    if (!searchDir) {
+      return [];
+    }
+
+    try {
+      const entries = fs.readdirSync(searchDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith('.')) continue; // Skip hidden
+
+        if (!prefix || entry.name.toLowerCase().startsWith(prefix)) {
+          results.push({
+            path: path.join(searchDir, entry.name),
+            name: entry.name,
+            type: 'filesystem'
+          });
+        }
+      }
+
+      // Sort alphabetically
+      results.sort((a, b) => a.name.localeCompare(b.name));
+    } catch (e) {
+      // Ignore errors (permission denied, etc.)
+    }
+
+    return results.slice(0, MAX_AUTOCOMPLETE_RESULTS);
+  }
+
+  /**
+   * Fuzzy match projects by query
+   * @param {string} query - Search query
+   * @returns {Array} Matching projects
+   */
+  function fuzzyMatchProjects(query) {
+    if (!query) {
+      return listProjects({ limit: MAX_AUTOCOMPLETE_RESULTS });
+    }
+
+    const lowerQuery = query.toLowerCase();
+    const matches = [];
+
+    for (const project of projects.values()) {
+      const nameMatch = project.name.toLowerCase().includes(lowerQuery);
+      const pathMatch = project.path.toLowerCase().includes(lowerQuery);
+
+      if (nameMatch || pathMatch) {
+        matches.push({
+          ...project,
+          type: 'known',
+          score: nameMatch ? 2 : 1
+        });
+      }
+    }
+
+    // Sort by score then by lastUsed
+    matches.sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      return b.lastUsed - a.lastUsed;
+    });
+
+    return matches.slice(0, MAX_AUTOCOMPLETE_RESULTS);
+  }
+
+  /**
+   * Get autocomplete suggestions for a query
+   * @param {string} query - User query
+   * @param {Object} options - Options
+   * @param {number} options.limit - Max results (default: 15)
+   * @returns {Array} Array of suggestions
+   */
+  function autocomplete(query, options = {}) {
+    const { limit = MAX_AUTOCOMPLETE_RESULTS } = options;
+
+    if (!query || !query.trim()) {
+      // Return recent projects
+      return listProjects({ limit }).map(p => ({
+        ...p,
+        type: 'known'
+      }));
+    }
+
+    const trimmed = query.trim();
+    const results = [];
+
+    // Check if this looks like a path (starts with / or ~)
+    const isPathLike = trimmed.startsWith('/') || trimmed.startsWith('~');
+
+    if (isPathLike) {
+      // Get filesystem completions first
+      const fsResults = getFilesystemCompletions(trimmed);
+      results.push(...fsResults);
+    }
+
+    // Also get fuzzy matches from known projects
+    const knownMatches = fuzzyMatchProjects(trimmed);
+    for (const match of knownMatches) {
+      // Don't duplicate filesystem results
+      if (!results.find(r => r.path === match.path)) {
+        results.push(match);
+      }
+    }
+
+    // If query is a path-like but no fs results, still try fs completion
+    if (!isPathLike && results.length < limit) {
+      const fsResults = getFilesystemCompletions(trimmed);
+      for (const r of fsResults) {
+        if (!results.find(existing => existing.path === r.path)) {
+          results.push(r);
+        }
+      }
+    }
+
+    return results.slice(0, limit);
+  }
+
+  /**
+   * Get common parent directories from tracked projects
+   * @returns {Array} Array of common directories
+   */
+  function getCommonDirectories() {
+    const dirCounts = new Map();
+
+    for (const project of projects.values()) {
+      // Get parent directories up to 3 levels
+      let current = path.dirname(project.path);
+      for (let i = 0; i < 3 && current !== path.dirname(current); i++) {
+        dirCounts.set(current, (dirCounts.get(current) || 0) + 1);
+        current = path.dirname(current);
+      }
+    }
+
+    // Return directories with multiple projects
+    const common = [];
+    for (const [dir, count] of dirCounts) {
+      if (count >= 2) {
+        common.push({ path: dir, projectCount: count });
+      }
+    }
+
+    common.sort((a, b) => b.projectCount - a.projectCount);
+    return common.slice(0, 10);
+  }
+
+  /**
+   * Clear all tracked projects
+   */
+  function clearProjects() {
+    projects.clear();
+    saveProjects();
+  }
+
+  /**
+   * Initialize the manager
+   */
+  function init() {
+    loadProjects();
+  }
+
+  // Initialize on creation
+  init();
+
+  return {
+    // Project CRUD
+    trackProject,
+    getProject,
+    listProjects,
+    removeProject,
+    clearProjects,
+
+    // Autocomplete
+    autocomplete,
+    getFilesystemCompletions,
+    fuzzyMatchProjects,
+
+    // Analysis
+    getCommonDirectories,
+
+    // Lifecycle
+    init,
+    loadProjects,
+    saveProjects
+  };
+}
+
+module.exports = {
+  createProjectsManager,
+  DEFAULT_DATA_DIR,
+  DEFAULT_PROJECTS_FILE,
+  MAX_TRACKED_PROJECTS,
+  MAX_AUTOCOMPLETE_RESULTS
+};