@haystackeditor/cli 0.4.0 → 0.6.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,6 +20,10 @@ 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);
@@ -304,3 +309,136 @@ async function hasFile(dir, file) {
         return false;
     }
 }
+/**
+ * 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>;