@haystackeditor/cli 0.5.0 → 0.7.0

package/dist/utils/detect.js

@@ -1,7 +1,8 @@
 /**
  * Project detection utilities
  *
- * Auto-detects framework, package manager, monorepo structure, and services.
+ * Auto-detects framework, package manager, monorepo structure, services,
+ * and inter-service dependencies from proxy configurations.
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
@@ -19,10 +20,19 @@ export async function detectProject(rootDir = process.cwd()) {
         result.isMonorepo = true;
         result.monorepoTool = monorepo.tool;
         result.services = await detectServices(rootDir, monorepo.workspaces);
+        // Detect proxy dependencies and add them to services
+        if (result.services && result.services.length > 0) {
+            result.services = await suggestServiceDependencies(rootDir, result.services);
+        }
     }
     // Detect framework
     result.framework = await detectFramework(rootDir);
-    // Set suggestions based on framework
+    // Extract custom port from config if framework supports it
+    const customPort = await extractPortFromConfig(rootDir, result.framework);
+    if (customPort) {
+        result.suggestedPort = customPort;
+    }
+    // Set suggestions based on framework (won't override customPort if set)
     setSuggestions(result);
     // Detect auth bypass from .env.example
     result.suggestedAuthBypass = await detectAuthBypass(rootDir);
@@ -183,12 +193,14 @@ async function detectService(rootDir, servicePath) {
     else if (await hasFile(fullPath, 'vite.config.ts') || await hasFile(fullPath, 'vite.config.js')) {
         framework = 'vite';
         suggestedCommand = 'pnpm dev';
-        suggestedPort = 5173;
+        // Try to extract custom port from vite config, fallback to default
+        suggestedPort = await extractPortFromConfig(fullPath, 'vite') ?? 5173;
     }
     else if (await hasFile(fullPath, 'next.config.js') || await hasFile(fullPath, 'next.config.ts')) {
         framework = 'nextjs';
         suggestedCommand = 'pnpm dev';
-        suggestedPort = 3000;
+        // Try to extract custom port from next config, fallback to default
+        suggestedPort = await extractPortFromConfig(fullPath, 'nextjs') ?? 3000;
     }
     else if (scripts.dev) {
         suggestedCommand = 'pnpm dev';
@@ -275,6 +287,7 @@ async function detectAuthBypass(rootDir) {
 }
 /**
  * Set suggestions based on detected framework
+ * Note: This is sync, so custom port extraction happens in detectProject
  */
 function setSuggestions(result) {
     const frameworkDefaults = {
@@ -289,7 +302,8 @@ function setSuggestions(result) {
     };
     const defaults = result.framework ? frameworkDefaults[result.framework] : null;
     result.suggestedDevCommand = defaults?.command || `${result.packageManager} dev`;
-    result.suggestedPort = defaults?.port || 3000;
+    // suggestedPort may already be set from custom config extraction
+    result.suggestedPort = result.suggestedPort || defaults?.port || 3000;
     result.suggestedReadyPattern = defaults?.ready || 'ready|started|listening|Local:';
 }
 /**
@@ -304,3 +318,188 @@ async function hasFile(dir, file) {
         return false;
     }
 }
+/**
+ * Extract custom port from framework config files
+ *
+ * Parses vite.config.ts, next.config.js, etc. to find custom port settings
+ * Returns undefined if no custom port is configured (use framework default)
+ */
+async function extractPortFromConfig(rootDir, framework) {
+    if (!framework)
+        return undefined;
+    // Config files to check based on framework
+    const configFiles = {
+        vite: ['vite.config.ts', 'vite.config.js', 'vite.config.mjs'],
+        nextjs: ['next.config.js', 'next.config.ts', 'next.config.mjs'],
+        nuxt: ['nuxt.config.ts', 'nuxt.config.js'],
+        sveltekit: ['svelte.config.js', 'svelte.config.ts'],
+        astro: ['astro.config.mjs', 'astro.config.ts'],
+    };
+    const files = configFiles[framework];
+    if (!files)
+        return undefined;
+    let configContent = null;
+    for (const file of files) {
+        try {
+            configContent = await fs.readFile(path.join(rootDir, file), 'utf-8');
+            break;
+        }
+        catch {
+            // File not found, try next
+        }
+    }
+    if (!configContent)
+        return undefined;
+    // Patterns to match port configuration
+    // Vite: server: { port: 3000 } or server.port = 3000
+    // Next: env: { PORT: 3000 } or experimental.serverPort
+    const patterns = [
+        /server\s*:\s*\{[^}]*port\s*:\s*(\d+)/s, // server: { port: 3000 }
+        /server\s*\.\s*port\s*[=:]\s*(\d+)/, // server.port = 3000
+        /port\s*:\s*(\d+)/, // port: 3000 (generic)
+        /PORT\s*[=:]\s*['"]?(\d+)['"]?/, // PORT = 3000
+    ];
+    for (const pattern of patterns) {
+        const match = configContent.match(pattern);
+        if (match) {
+            const port = parseInt(match[1], 10);
+            if (port > 0 && port < 65536) {
+                return port;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Detect proxy dependencies from vite.config.ts/js
+ *
+ * Parses the vite config file to find proxy targets that point to localhost,
+ * which indicate dependencies on other local services.
+ *
+ * @example
+ * // vite.config.ts with proxy
+ * server: {
+ *   proxy: {
+ *     '/api/review-chat': {
+ *       target: 'http://localhost:8787',
+ *     }
+ *   }
+ * }
+ * // Returns: [{ path: '/api/review-chat', port: 8787, host: 'localhost' }]
+ */
+export async function detectProxyDependencies(rootDir) {
+    const dependencies = [];
+    // Try vite.config.ts, then vite.config.js
+    const configFiles = ['vite.config.ts', 'vite.config.js', 'vite.config.mjs'];
+    let configContent = null;
+    for (const file of configFiles) {
+        try {
+            configContent = await fs.readFile(path.join(rootDir, file), 'utf-8');
+            break;
+        }
+        catch {
+            // File not found, try next
+        }
+    }
+    if (!configContent) {
+        return dependencies;
+    }
+    // Parse proxy configurations using regex
+    // Matches patterns like:
+    //   '/api/path': { target: 'http://localhost:8787' }
+    //   '/api/path': 'http://localhost:8787'
+    //   proxy: { '/api/path': { target: 'http://localhost:8787' } }
+    // Pattern for object-style proxy: '/path': { target: 'http://localhost:PORT' }
+    const objectProxyRegex = /['"]([^'"]+)['"]\s*:\s*\{[^}]*target\s*:\s*['"]https?:\/\/(localhost|127\.0\.0\.1):(\d+)['"]/g;
+    let match;
+    while ((match = objectProxyRegex.exec(configContent)) !== null) {
+        dependencies.push({
+            path: match[1],
+            host: match[2],
+            port: parseInt(match[3], 10),
+        });
+    }
+    // Pattern for string-style proxy: '/path': 'http://localhost:PORT'
+    const stringProxyRegex = /['"]([^'"]+)['"]\s*:\s*['"]https?:\/\/(localhost|127\.0\.0\.1):(\d+)['"]/g;
+    let stringMatch;
+    while ((stringMatch = stringProxyRegex.exec(configContent)) !== null) {
+        // Avoid duplicates from object pattern
+        const exists = dependencies.some(d => d.path === stringMatch[1] && d.port === parseInt(stringMatch[3], 10));
+        if (!exists) {
+            dependencies.push({
+                path: stringMatch[1],
+                host: stringMatch[2],
+                port: parseInt(stringMatch[3], 10),
+            });
+        }
+    }
+    return dependencies;
+}
+/**
+ * Match proxy dependencies to detected services
+ *
+ * Given a list of proxy targets (ports) and detected services,
+ * determines which services are dependencies based on port matching.
+ */
+export function matchProxyToServices(proxyDeps, services) {
+    // Create a port → service name mapping
+    const portToService = new Map();
+    for (const service of services) {
+        if (service.suggestedPort) {
+            portToService.set(service.suggestedPort, service.name);
+        }
+    }
+    // For each service that has proxy deps pointing to another service's port,
+    // record the dependency
+    const serviceDeps = new Map();
+    for (const dep of proxyDeps) {
+        const matchedService = portToService.get(dep.port);
+        if (matchedService) {
+            dep.matchedService = matchedService;
+        }
+    }
+    return serviceDeps;
+}
+/**
+ * Suggest depends_on for services based on proxy configuration
+ *
+ * For the main service (usually frontend), detect if it proxies to other local services
+ * and suggest those as dependencies.
+ */
+export async function suggestServiceDependencies(rootDir, services) {
+    // Detect proxy dependencies from vite config
+    const proxyDeps = await detectProxyDependencies(rootDir);
+    if (proxyDeps.length === 0) {
+        return services;
+    }
+    // Create port → service mapping
+    const portToService = new Map();
+    for (const service of services) {
+        if (service.suggestedPort) {
+            portToService.set(service.suggestedPort, service.name);
+        }
+    }
+    // Match proxy ports to services
+    const dependsOn = [];
+    for (const dep of proxyDeps) {
+        const serviceName = portToService.get(dep.port);
+        if (serviceName) {
+            dep.matchedService = serviceName;
+            if (!dependsOn.includes(serviceName)) {
+                dependsOn.push(serviceName);
+            }
+        }
+    }
+    // Update the main frontend service with depends_on
+    // The main service is typically the one at root with port 3000/5173
+    return services.map(service => {
+        // If this service is at root and has detected proxy dependencies
+        if ((service.root === '.' || service.root === './') && dependsOn.length > 0) {
+            return {
+                ...service,
+                suggestedDependsOn: dependsOn,
+            };
+        }
+        return service;
+    });
+}

package/dist/utils/secrets.d.ts

@@ -30,7 +30,7 @@ export declare function scanForSecrets(content: string, filename: string): Secre
  */
 export declare function scanFile(filePath: string): Promise<SecretFinding[]>;
 /**
- * Scan .haystack.yml specifically for secrets
+ * Scan .haystack.json specifically for secrets
  */
 export declare function scanHaystackConfig(configPath: string): Promise<SecretFinding[]>;
 /**

package/dist/utils/secrets.js

@@ -202,7 +202,7 @@ export async function scanFile(filePath) {
     }
 }
 /**
- * Scan .haystack.yml specifically for secrets
+ * Scan .haystack.json specifically for secrets
  */
 export async function scanHaystackConfig(configPath) {
     return scanFile(configPath);

package/dist/utils/skill.d.ts

@@ -4,7 +4,7 @@
  */
 export declare function createSkillFile(): Promise<string>;
 /**
- * Create the .claude/commands/haystack.md file for Claude Code slash command
- * Users can invoke with /haystack to start the setup wizard
+ * Create the .claude/commands/ files for Claude Code slash commands
+ * Users can invoke with /setup-haystack or /prepare-haystack
  */
 export declare function createClaudeCommand(): Promise<string>;