@hivehub/rulebook 3.3.1 → 4.0.0

package/dist/core/cursor-mdc-generator.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Cursor MDC Rules Generator
+ *
+ * Generates .cursor/rules/*.mdc files for Cursor IDE v0.45+.
+ * The new .mdc format replaces the deprecated .cursorrules file and supports:
+ * - YAML frontmatter (description, globs, alwaysApply)
+ * - Multiple scoped rule files
+ * - On-demand loading based on file globs
+ */
+export interface CursorMdcOptions {
+    languages: string[];
+    ralphEnabled: boolean;
+    rulebookDir?: string;
+}
+export interface CursorMdcResult {
+    generated: string[];
+    skipped: string[];
+}
+/**
+ * Check if Cursor IDE is being used in the project.
+ * Detects: .cursor/ directory, .cursorrules, .cursor/mcp.json
+ */
+export declare function isCursorInstalled(projectRoot: string): boolean;
+/**
+ * Generate .cursor/rules/*.mdc files for the project.
+ * Always generates: rulebook.mdc, quality.mdc
+ * Conditionally generates: ralph.mdc (if Ralph enabled), <language>.mdc
+ */
+export declare function generateCursorMdcRules(projectRoot: string, options: CursorMdcOptions): Promise<CursorMdcResult>;
+//# sourceMappingURL=cursor-mdc-generator.d.ts.map

package/dist/core/cursor-mdc-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-mdc-generator.d.ts","sourceRoot":"","sources":["../../src/core/cursor-mdc-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAoBH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAK9D;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA4C1B"}

package/dist/core/cursor-mdc-generator.js

@@ -0,0 +1,98 @@
+/**
+ * Cursor MDC Rules Generator
+ *
+ * Generates .cursor/rules/*.mdc files for Cursor IDE v0.45+.
+ * The new .mdc format replaces the deprecated .cursorrules file and supports:
+ * - YAML frontmatter (description, globs, alwaysApply)
+ * - Multiple scoped rule files
+ * - On-demand loading based on file globs
+ */
+import path from 'path';
+import { existsSync } from 'fs';
+import { readFile as fsReadFile, writeFile, mkdir } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Language → .mdc template name
+const LANGUAGE_MDC_MAP = {
+    typescript: 'typescript',
+    javascript: 'typescript', // share the TS template for JS projects
+    python: 'python',
+    rust: 'rust',
+    go: 'go',
+};
+/**
+ * Check if Cursor IDE is being used in the project.
+ * Detects: .cursor/ directory, .cursorrules, .cursor/mcp.json
+ */
+export function isCursorInstalled(projectRoot) {
+    return (existsSync(path.join(projectRoot, '.cursor')) ||
+        existsSync(path.join(projectRoot, '.cursorrules')));
+}
+/**
+ * Generate .cursor/rules/*.mdc files for the project.
+ * Always generates: rulebook.mdc, quality.mdc
+ * Conditionally generates: ralph.mdc (if Ralph enabled), <language>.mdc
+ */
+export async function generateCursorMdcRules(projectRoot, options) {
+    const rulesDir = path.join(projectRoot, '.cursor', 'rules');
+    await mkdir(rulesDir, { recursive: true });
+    const result = { generated: [], skipped: [] };
+    const templatesDir = getTemplatesDir();
+    // Always-generate files: rulebook.mdc, quality.mdc
+    const alwaysFiles = ['rulebook', 'quality'];
+    for (const name of alwaysFiles) {
+        const wrote = await writeMdcFile(rulesDir, name, templatesDir);
+        if (wrote) {
+            result.generated.push(`${name}.mdc`);
+        }
+        else {
+            result.skipped.push(`${name}.mdc`);
+        }
+    }
+    // Ralph directives (only if ralph is enabled in config)
+    if (options.ralphEnabled) {
+        const wrote = await writeMdcFile(rulesDir, 'ralph', templatesDir);
+        if (wrote) {
+            result.generated.push('ralph.mdc');
+        }
+        else {
+            result.skipped.push('ralph.mdc');
+        }
+    }
+    // Language-specific files
+    const writtenLangTemplates = new Set();
+    for (const lang of options.languages) {
+        const templateName = LANGUAGE_MDC_MAP[lang.toLowerCase()];
+        if (!templateName || writtenLangTemplates.has(templateName))
+            continue;
+        writtenLangTemplates.add(templateName);
+        const wrote = await writeMdcFile(rulesDir, templateName, templatesDir);
+        if (wrote) {
+            result.generated.push(`${templateName}.mdc`);
+        }
+        else {
+            result.skipped.push(`${templateName}.mdc`);
+        }
+    }
+    return result;
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function getTemplatesDir() {
+    return path.join(__dirname, '..', '..', 'templates', 'ides', 'cursor-mdc');
+}
+/**
+ * Write a single .mdc file from template. Returns true if file was written.
+ */
+async function writeMdcFile(rulesDir, name, templatesDir) {
+    const templatePath = path.join(templatesDir, `${name}.mdc`);
+    if (!existsSync(templatePath)) {
+        return false;
+    }
+    const content = await fsReadFile(templatePath, 'utf-8');
+    const destPath = path.join(rulesDir, `${name}.mdc`);
+    await writeFile(destPath, content, 'utf-8');
+    return true;
+}
+//# sourceMappingURL=cursor-mdc-generator.js.map

package/dist/core/cursor-mdc-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-mdc-generator.js","sourceRoot":"","sources":["../../src/core/cursor-mdc-generator.ts"],"names":[],"mappings":"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"}

package/dist/core/detector.d.ts

@@ -1,3 +1,27 @@
-import type { DetectionResult } from '../types.js';
+import type { DetectionResult, MonorepoDetection } from '../types.js';
 export declare function detectProject(cwd?: string): Promise<DetectionResult>;
+/**
+ * Detect Cursor IDE presence and configuration status.
+ */
+export declare function detectCursor(cwd: string): Promise<DetectionResult['cursor']>;
+/**
+ * Detect Gemini CLI presence by checking for GEMINI.md in the project root.
+ */
+export declare function detectGeminiCli(cwd: string): Promise<NonNullable<DetectionResult['geminiCli']>>;
+/**
+ * Detect Continue.dev IDE extension by checking for the .continue/ directory.
+ */
+export declare function detectContinueDev(cwd: string): Promise<NonNullable<DetectionResult['continueDev']>>;
+/**
+ * Detect Windsurf IDE by checking for .windsurfrules in the project root.
+ */
+export declare function detectWindsurf(cwd: string): Promise<NonNullable<DetectionResult['windsurf']>>;
+/**
+ * Detect GitHub Copilot by checking for .github/copilot-instructions.md.
+ */
+export declare function detectGithubCopilot(cwd: string): Promise<NonNullable<DetectionResult['githubCopilot']>>;
+/**
+ * Detect monorepo structure: Turborepo, Nx, pnpm workspaces, Lerna, or manual.
+ */
+export declare function detectMonorepo(cwd: string): Promise<MonorepoDetection>;
 //# sourceMappingURL=detector.d.ts.map

package/dist/core/detector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../src/core/detector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EAShB,MAAM,aAAa,CAAC;AAErB,wBAAsB,aAAa,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,eAAe,CAAC,CAgBzF"}
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../src/core/detector.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,eAAe,EASf,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAErB,wBAAsB,aAAa,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,eAAe,CAAC,CA4BzF;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAoBlF;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,CAIpD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC,CAKtD;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAInD;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,CAIxD;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAgC5E"}

package/dist/core/detector.js

@@ -1,4 +1,6 @@
 import path from 'path';
+import { existsSync } from 'fs';
+import { readdir } from 'fs/promises';
 import { fileExists, findFiles, readFile, readJsonFile } from '../utils/file-system.js';
 export async function detectProject(cwd = process.cwd()) {
     const languages = await detectLanguages(cwd);
@@ -7,6 +9,12 @@ export async function detectProject(cwd = process.cwd()) {
     const services = await detectServices(cwd);
     const existingAgents = await detectExistingAgents(cwd);
     const gitHooks = await detectGitHooks(cwd);
+    const monorepo = await detectMonorepo(cwd);
+    const cursor = await detectCursor(cwd);
+    const geminiCli = await detectGeminiCli(cwd);
+    const continueDev = await detectContinueDev(cwd);
+    const windsurf = await detectWindsurf(cwd);
+    const githubCopilot = await detectGithubCopilot(cwd);
     return {
         languages,
         modules,
@@ -14,8 +22,127 @@ export async function detectProject(cwd = process.cwd()) {
         services,
         existingAgents,
         gitHooks,
+        monorepo,
+        cursor,
+        geminiCli,
+        continueDev,
+        windsurf,
+        githubCopilot,
     };
 }
+/**
+ * Detect Cursor IDE presence and configuration status.
+ */
+export async function detectCursor(cwd) {
+    const cursorDir = path.join(cwd, '.cursor');
+    const cursorrules = path.join(cwd, '.cursorrules');
+    const rulesDir = path.join(cursorDir, 'rules');
+    const hasCursorDir = existsSync(cursorDir);
+    const hasCursorrules = existsSync(cursorrules);
+    const detected = hasCursorDir || hasCursorrules;
+    let hasMdcRules = false;
+    if (existsSync(rulesDir)) {
+        try {
+            const files = await readdir(rulesDir);
+            hasMdcRules = files.some((f) => f.endsWith('.mdc'));
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { detected, hasCursorrules, hasMdcRules };
+}
+/**
+ * Detect Gemini CLI presence by checking for GEMINI.md in the project root.
+ */
+export async function detectGeminiCli(cwd) {
+    const geminiMd = path.join(cwd, 'GEMINI.md');
+    const detected = existsSync(geminiMd);
+    return { detected };
+}
+/**
+ * Detect Continue.dev IDE extension by checking for the .continue/ directory.
+ */
+export async function detectContinueDev(cwd) {
+    const continueDir = path.join(cwd, '.continue');
+    const rulesDir = path.join(continueDir, 'rules');
+    const detected = existsSync(continueDir);
+    return { detected, rulesDir };
+}
+/**
+ * Detect Windsurf IDE by checking for .windsurfrules in the project root.
+ */
+export async function detectWindsurf(cwd) {
+    const windsurfrules = path.join(cwd, '.windsurfrules');
+    const detected = existsSync(windsurfrules);
+    return { detected };
+}
+/**
+ * Detect GitHub Copilot by checking for .github/copilot-instructions.md.
+ */
+export async function detectGithubCopilot(cwd) {
+    const copilotInstructions = path.join(cwd, '.github', 'copilot-instructions.md');
+    const detected = existsSync(copilotInstructions);
+    return { detected };
+}
+/**
+ * Detect monorepo structure: Turborepo, Nx, pnpm workspaces, Lerna, or manual.
+ */
+export async function detectMonorepo(cwd) {
+    // Turborepo
+    if (existsSync(path.join(cwd, 'turbo.json'))) {
+        const packages = await discoverPackages(cwd);
+        return { detected: true, tool: 'turborepo', packages };
+    }
+    // Nx
+    if (existsSync(path.join(cwd, 'nx.json'))) {
+        const packages = await discoverPackages(cwd);
+        return { detected: true, tool: 'nx', packages };
+    }
+    // pnpm workspaces
+    if (existsSync(path.join(cwd, 'pnpm-workspace.yaml'))) {
+        const packages = await discoverPackages(cwd);
+        return { detected: true, tool: 'pnpm', packages };
+    }
+    // Lerna
+    if (existsSync(path.join(cwd, 'lerna.json'))) {
+        const packages = await discoverPackages(cwd);
+        return { detected: true, tool: 'lerna', packages };
+    }
+    // Manual monorepo — packages/ or apps/ directory with multiple package.json files
+    const packages = await discoverPackages(cwd);
+    if (packages.length >= 2) {
+        return { detected: true, tool: 'manual', packages };
+    }
+    return { detected: false, tool: null, packages: [] };
+}
+/**
+ * Discover package directories by looking for package.json in packages/ and apps/.
+ */
+async function discoverPackages(cwd) {
+    const packageDirs = [];
+    const searchDirs = ['packages', 'apps', 'libs', 'services'];
+    for (const searchDir of searchDirs) {
+        const absDir = path.join(cwd, searchDir);
+        if (!existsSync(absDir))
+            continue;
+        try {
+            const entries = await readdir(absDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const pkgJson = path.join(absDir, entry.name, 'package.json');
+                if (existsSync(pkgJson)) {
+                    packageDirs.push(`${searchDir}/${entry.name}`);
+                }
+            }
+        }
+        catch {
+            // ignore unreadable dirs
+        }
+    }
+    return packageDirs;
+}
 async function detectLanguages(cwd) {
     const detections = [];
     // Detect Rust
@@ -762,6 +889,21 @@ async function detectModules(cwd) {
                             source: mcpPath,
                         });
                     }
+                    // Check for Sequential Thinking MCP Server (various key names)
+                    const seqKeys = ['sequential-thinking', 'sequential_thinking', 'sequentialThinking'];
+                    const hasSeqThinking = seqKeys.some((k) => config.mcpServers?.[k] || config.servers?.[k]) ||
+                        Object.entries(config.mcpServers ?? {}).some(([, v]) => typeof v === 'object' &&
+                            v !== null &&
+                            'args' in v &&
+                            Array.isArray(v.args) &&
+                            v.args.some((a) => typeof a === 'string' && a.includes('sequential-thinking')));
+                    if (hasSeqThinking) {
+                        modules.push({
+                            module: 'sequential_thinking',
+                            detected: true,
+                            source: mcpPath,
+                        });
+                    }
                 }
             }
             catch {
@@ -771,7 +913,15 @@ async function detectModules(cwd) {
     }
     // Add undetected modules
     const detectedModules = new Set(modules.map((m) => m.module));
-    const allModules = ['vectorizer', 'synap', 'context7', 'github', 'playwright', 'rulebook_mcp'];
+    const allModules = [
+        'vectorizer',
+        'synap',
+        'context7',
+        'github',
+        'playwright',
+        'rulebook_mcp',
+        'sequential_thinking',
+    ];
     for (const module of allModules) {
         if (!detectedModules.has(module)) {
             modules.push({
@@ -1044,6 +1194,75 @@ async function detectServices(cwd) {
                     source: packageJson,
                 });
             }
+            // Sentry
+            if (allDeps['@sentry/node'] ||
+                allDeps['@sentry/react'] ||
+                allDeps['@sentry/nextjs'] ||
+                allDeps['@sentry/browser']) {
+                services.push({
+                    service: 'sentry',
+                    detected: true,
+                    confidence: 0.9,
+                    indicators: ['@sentry/node', '@sentry/react', '@sentry/nextjs', '@sentry/browser'].filter((dep) => allDeps[dep]),
+                    source: packageJson,
+                });
+            }
+            // OpenTelemetry
+            if (allDeps['@opentelemetry/sdk-node'] ||
+                allDeps['@opentelemetry/api'] ||
+                allDeps['@opentelemetry/auto-instrumentations-node']) {
+                services.push({
+                    service: 'opentelemetry',
+                    detected: true,
+                    confidence: 0.9,
+                    indicators: [
+                        '@opentelemetry/sdk-node',
+                        '@opentelemetry/api',
+                        '@opentelemetry/auto-instrumentations-node',
+                    ].filter((dep) => allDeps[dep]),
+                    source: packageJson,
+                });
+            }
+            // Datadog
+            if (allDeps['dd-trace'] || allDeps['datadog-lambda-js']) {
+                services.push({
+                    service: 'datadog',
+                    detected: true,
+                    confidence: 0.9,
+                    indicators: ['dd-trace', 'datadog-lambda-js'].filter((dep) => allDeps[dep]),
+                    source: packageJson,
+                });
+            }
+            // Pino
+            if (allDeps['pino'] || allDeps['pino-http']) {
+                services.push({
+                    service: 'pino',
+                    detected: true,
+                    confidence: 0.9,
+                    indicators: ['pino', 'pino-http'].filter((dep) => allDeps[dep]),
+                    source: packageJson,
+                });
+            }
+            // Winston
+            if (allDeps['winston'] || allDeps['winston-transport']) {
+                services.push({
+                    service: 'winston',
+                    detected: true,
+                    confidence: 0.9,
+                    indicators: ['winston', 'winston-transport'].filter((dep) => allDeps[dep]),
+                    source: packageJson,
+                });
+            }
+            // Prometheus
+            if (allDeps['prom-client'] || allDeps['express-prometheus-middleware']) {
+                services.push({
+                    service: 'prometheus',
+                    detected: true,
+                    confidence: 0.9,
+                    indicators: ['prom-client', 'express-prometheus-middleware'].filter((dep) => allDeps[dep]),
+                    source: packageJson,
+                });
+            }
         }
         catch {
             // Ignore JSON parse errors
@@ -1404,6 +1623,97 @@ async function detectServices(cwd) {
             }
         }
     }
+    // Detect container/orchestration services (Docker, Docker Compose, Kubernetes, Helm)
+    const dockerfile = path.join(cwd, 'Dockerfile');
+    const dockerignore = path.join(cwd, '.dockerignore');
+    const k8sDir = path.join(cwd, 'k8s');
+    const kubernetesDir = path.join(cwd, 'kubernetes');
+    const chartYaml = path.join(cwd, 'Chart.yaml');
+    const chartsDir = path.join(cwd, 'charts');
+    // Docker
+    if ((await fileExists(dockerfile)) || (await fileExists(dockerignore))) {
+        const indicators = [];
+        if (await fileExists(dockerfile))
+            indicators.push('Dockerfile');
+        if (await fileExists(dockerignore))
+            indicators.push('.dockerignore');
+        services.push({
+            service: 'docker',
+            detected: true,
+            confidence: 0.95,
+            indicators,
+            source: indicators[0],
+        });
+    }
+    // Docker Compose
+    if ((await fileExists(dockerCompose)) || (await fileExists(dockerComposeYaml))) {
+        const indicators = [];
+        if (await fileExists(dockerCompose))
+            indicators.push('docker-compose.yml');
+        if (await fileExists(dockerComposeYaml))
+            indicators.push('docker-compose.yaml');
+        services.push({
+            service: 'docker-compose',
+            detected: true,
+            confidence: 0.95,
+            indicators,
+            source: indicators[0],
+        });
+    }
+    // Kubernetes
+    const k8sDirExists = existsSync(k8sDir);
+    const kubernetesDirExists = existsSync(kubernetesDir);
+    let k8sYamlDetected = false;
+    if (!k8sDirExists && !kubernetesDirExists) {
+        // Scan root-level YAML files for Kubernetes resource kinds
+        try {
+            const rootFiles = await readdir(cwd);
+            const yamlFiles = rootFiles.filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
+            for (const yamlFile of yamlFiles) {
+                const content = await readFile(path.join(cwd, yamlFile));
+                if (content.includes('kind: Deployment') ||
+                    content.includes('kind: Service') ||
+                    content.includes('kind: Ingress')) {
+                    k8sYamlDetected = true;
+                    break;
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    if (k8sDirExists || kubernetesDirExists || k8sYamlDetected) {
+        const indicators = [];
+        if (k8sDirExists)
+            indicators.push('k8s/ directory');
+        if (kubernetesDirExists)
+            indicators.push('kubernetes/ directory');
+        if (k8sYamlDetected)
+            indicators.push('YAML with kind: Deployment/Service/Ingress');
+        services.push({
+            service: 'kubernetes',
+            detected: true,
+            confidence: 0.9,
+            indicators,
+        });
+    }
+    // Helm
+    const chartYamlExists = await fileExists(chartYaml);
+    const chartsDirExists = existsSync(chartsDir);
+    if (chartYamlExists || chartsDirExists) {
+        const indicators = [];
+        if (chartYamlExists)
+            indicators.push('Chart.yaml');
+        if (chartsDirExists)
+            indicators.push('charts/ directory');
+        services.push({
+            service: 'helm',
+            detected: true,
+            confidence: 0.9,
+            indicators,
+        });
+    }
     // Add undetected services (for manual selection)
     const detectedServices = new Set(services.map((s) => s.service));
     const allServices = [
@@ -1427,6 +1737,16 @@ async function detectServices(cwd) {
         'azure_blob',
         'gcs',
         'minio',
+        'docker',
+        'docker-compose',
+        'kubernetes',
+        'helm',
+        'sentry',
+        'opentelemetry',
+        'datadog',
+        'pino',
+        'winston',
+        'prometheus',
     ];
     for (const service of allServices) {
         if (!detectedServices.has(service)) {