@esthernandez/vibe-doc 0.1.0

package/dist/classifier/scoring-engine.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Scoring Engine Module
+ * Rule-based matrix for categorizing projects and contexts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.Category = void 0;
+exports.scoreClassification = scoreClassification;
+const logger_1 = require("../utils/logger");
+var Category;
+(function (Category) {
+    Category["WebApplication"] = "WebApplication";
+    Category["APIMicroservice"] = "APIMicroservice";
+    Category["DataPipeline"] = "DataPipeline";
+    Category["InfrastructurePlatform"] = "InfrastructurePlatform";
+    Category["MobileApplication"] = "MobileApplication";
+    Category["AIMLSystem"] = "AIMLSystem";
+    Category["IntegrationConnector"] = "IntegrationConnector";
+})(Category || (exports.Category = Category = {}));
+var Context;
+(function (Context) {
+    Context["Regulated"] = "Regulated";
+    Context["CustomerFacing"] = "CustomerFacing";
+    Context["InternalTooling"] = "InternalTooling";
+    Context["MultiTenant"] = "MultiTenant";
+    Context["EdgeEmbedded"] = "EdgeEmbedded";
+})(Context || (exports.Context = Context = {}));
+/**
+ * Score classification based on signals
+ * @param signals - Array of detected signals
+ * @param confidenceThreshold - Threshold for high confidence classification (default: 0.85)
+ */
+function scoreClassification(signals, confidenceThreshold = 0.85) {
+    const categoryScores = {};
+    const contextScores = {};
+    // Initialize scores
+    Object.values(Category).forEach((cat) => {
+        categoryScores[cat] = 0;
+    });
+    Object.values(Context).forEach((ctx) => {
+        contextScores[ctx] = 0;
+    });
+    // Apply signal scoring rules
+    for (const signal of signals) {
+        const w = signal.weight;
+        switch (signal.name) {
+            // Web framework signals
+            case 'has-express-routes':
+                categoryScores[Category.WebApplication] += 3 * w;
+                categoryScores[Category.APIMicroservice] += 3 * w;
+                break;
+            // Frontend signals
+            case 'has-react-components':
+                categoryScores[Category.WebApplication] += 4 * w;
+                break;
+            // Infrastructure signals
+            case 'has-dockerfile':
+                Object.values(Category).forEach((cat) => {
+                    categoryScores[cat] += 1 * w;
+                });
+                break;
+            case 'has-terraform':
+                categoryScores[Category.InfrastructurePlatform] += 4 * w;
+                break;
+            // Python web framework signals
+            case 'has-flask-fastapi-django':
+                categoryScores[Category.WebApplication] += 3 * w;
+                categoryScores[Category.APIMicroservice] += 3 * w;
+                break;
+            // ML signals
+            case 'has-ml-model-files':
+                categoryScores[Category.AIMLSystem] += 5 * w;
+                break;
+            case 'has-ml-dependencies':
+                categoryScores[Category.AIMLSystem] += 4 * w;
+                break;
+            // Data pipeline signals
+            case 'has-etl-pipeline-keywords':
+                categoryScores[Category.DataPipeline] += 4 * w;
+                break;
+            // Mobile signals
+            case 'has-mobile-configs':
+                categoryScores[Category.MobileApplication] += 5 * w;
+                break;
+            // Integration signals
+            case 'has-third-party-api-clients':
+                categoryScores[Category.IntegrationConnector] += 3 * w;
+                break;
+            // Context signals
+            case 'has-compliance-requirements':
+                contextScores[Context.Regulated] += 5 * w;
+                break;
+            case 'has-rbac-tenant-patterns':
+                contextScores[Context.MultiTenant] += 3 * w;
+                break;
+            case 'has-sla-uptime-mentions':
+                contextScores[Context.CustomerFacing] += 3 * w;
+                break;
+            case 'has-internal-tooling':
+                contextScores[Context.InternalTooling] += 3 * w;
+                break;
+            // Quality signals
+            case 'has-tests':
+                // Boost all categories slightly
+                Object.values(Category).forEach((cat) => {
+                    categoryScores[cat] += 0.5 * w;
+                });
+                break;
+            case 'has-api-spec':
+                categoryScores[Category.APIMicroservice] += 3 * w;
+                categoryScores[Category.WebApplication] += 1 * w;
+                break;
+            case 'has-microservices-pattern':
+                categoryScores[Category.APIMicroservice] += 2 * w;
+                categoryScores[Category.InfrastructurePlatform] += 1 * w;
+                break;
+            case 'has-database-orm':
+                categoryScores[Category.WebApplication] += 1 * w;
+                categoryScores[Category.APIMicroservice] += 1.5 * w;
+                categoryScores[Category.DataPipeline] += 1 * w;
+                break;
+            case 'has-monitoring-logging':
+                categoryScores[Category.InfrastructurePlatform] += 2 * w;
+                contextScores[Context.CustomerFacing] += 1 * w;
+                break;
+            // New 626Labs-specific signals
+            case 'has-firebase':
+                categoryScores[Category.WebApplication] += 3 * w;
+                categoryScores[Category.APIMicroservice] += 2 * w;
+                break;
+            case 'has-vite-config':
+                categoryScores[Category.WebApplication] += 2 * w;
+                break;
+            case 'has-tailwind':
+                categoryScores[Category.WebApplication] += 1 * w;
+                break;
+            case 'has-nextjs-nuxt':
+                categoryScores[Category.WebApplication] += 4 * w;
+                break;
+            case 'has-cloud-functions':
+                categoryScores[Category.APIMicroservice] += 3 * w;
+                categoryScores[Category.WebApplication] += 1 * w;
+                break;
+            case 'has-ai-sdk':
+                categoryScores[Category.AIMLSystem] += 3 * w;
+                categoryScores[Category.WebApplication] += 1 * w;
+                break;
+            case 'has-mcp-server':
+                categoryScores[Category.APIMicroservice] += 2 * w;
+                categoryScores[Category.IntegrationConnector] += 2 * w;
+                break;
+            case 'has-state-management':
+                categoryScores[Category.WebApplication] += 2 * w;
+                break;
+            case 'has-e2e-testing':
+                Object.values(Category).forEach((cat) => {
+                    categoryScores[cat] += 0.5 * w;
+                });
+                break;
+            case 'has-github-actions':
+                contextScores[Context.InternalTooling] += 1 * w;
+                break;
+            default:
+                logger_1.logger.warn(`Unknown signal: ${signal.name}`);
+        }
+    }
+    // Build sorted category results
+    const sortedCategories = Object.entries(categoryScores)
+        .map(([category, score]) => ({
+        category: category,
+        score,
+    }))
+        .sort((a, b) => b.score - a.score);
+    // Build context results (filter out zero scores)
+    const activeContexts = Object.entries(contextScores)
+        .filter(([_, score]) => score > 0)
+        .map(([context, score]) => ({
+        context: context,
+        score,
+    }))
+        .sort((a, b) => b.score - a.score);
+    // Calculate confidence using 2x gap rule
+    let confidence = 0;
+    if (sortedCategories.length >= 2) {
+        const gap = sortedCategories[0].score - sortedCategories[1].score;
+        const maxScore = sortedCategories[0].score;
+        confidence = gap > maxScore * (1 - confidenceThreshold) ? 1.0 : 0.5;
+    }
+    else if (sortedCategories.length === 1 && sortedCategories[0].score > 0) {
+        confidence = 1.0;
+    }
+    return {
+        categories: sortedCategories,
+        contexts: activeContexts,
+        confidence,
+    };
+}

package/dist/classifier/signals.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Signal Extraction Module
+ * Extracts named observations from scan results with weights
+ */
+import { ArtifactInventory } from '../state/schema';
+export interface Signal {
+    name: string;
+    source: string;
+    weight: number;
+}
+/**
+ * Extract signals from artifact inventory
+ * Each signal is a named observation with a source and weight
+ */
+export declare function extractSignals(inventory: ArtifactInventory): Signal[];
+//# sourceMappingURL=signals.d.ts.map

package/dist/classifier/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../../src/classifier/signals.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGpD,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAgWrE"}

package/dist/classifier/signals.js

@@ -0,0 +1,305 @@
+"use strict";
+/**
+ * Signal Extraction Module
+ * Extracts named observations from scan results with weights
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSignals = extractSignals;
+const logger_1 = require("../utils/logger");
+/**
+ * Extract signals from artifact inventory
+ * Each signal is a named observation with a source and weight
+ */
+function extractSignals(inventory) {
+    const signals = [];
+    // Source code patterns
+    const sourceFiles = inventory.categories.sourceCode.files.join('|').toLowerCase();
+    const configFiles = inventory.categories.configuration.files.join('|').toLowerCase();
+    const infraFiles = inventory.categories.infrastructure.files.join('|').toLowerCase();
+    const docFiles = inventory.categories.documentation.files.join('|').toLowerCase();
+    const allFiles = inventory.categories.sourceCode.files
+        .concat(inventory.categories.configuration.files)
+        .concat(inventory.categories.infrastructure.files)
+        .join('|')
+        .toLowerCase();
+    // Express/Fastify/Koa routes
+    if (sourceFiles.includes('routes') || sourceFiles.includes('controller')) {
+        if (allFiles.includes('express') ||
+            allFiles.includes('fastify') ||
+            allFiles.includes('koa')) {
+            signals.push({
+                name: 'has-express-routes',
+                source: 'code-scanner',
+                weight: 3,
+            });
+        }
+    }
+    // React/Vue/Svelte components
+    if (sourceFiles.includes('.tsx') ||
+        sourceFiles.includes('.jsx') ||
+        sourceFiles.includes('.vue') ||
+        sourceFiles.includes('.svelte')) {
+        signals.push({
+            name: 'has-react-components',
+            source: 'file-scanner',
+            weight: 4,
+        });
+    }
+    // Dockerfile
+    if (infraFiles.includes('dockerfile')) {
+        signals.push({
+            name: 'has-dockerfile',
+            source: 'file-scanner',
+            weight: 1,
+        });
+    }
+    // Terraform
+    if (infraFiles.includes('.tf')) {
+        signals.push({
+            name: 'has-terraform',
+            source: 'file-scanner',
+            weight: 4,
+        });
+    }
+    // Flask/FastAPI/Django
+    if (allFiles.includes('flask') ||
+        allFiles.includes('fastapi') ||
+        allFiles.includes('django')) {
+        if (sourceFiles.includes('.py')) {
+            signals.push({
+                name: 'has-flask-fastapi-django',
+                source: 'code-scanner',
+                weight: 3,
+            });
+        }
+    }
+    // ML model files
+    if (sourceFiles.includes('.pkl') || sourceFiles.includes('.h5') || sourceFiles.includes('.onnx')) {
+        signals.push({
+            name: 'has-ml-model-files',
+            source: 'file-scanner',
+            weight: 5,
+        });
+    }
+    // ML dependencies
+    if (allFiles.includes('torch') ||
+        allFiles.includes('tensorflow') ||
+        allFiles.includes('transformers') ||
+        allFiles.includes('sklearn')) {
+        signals.push({
+            name: 'has-ml-dependencies',
+            source: 'code-scanner',
+            weight: 4,
+        });
+    }
+    // ETL pipeline keywords
+    if (sourceFiles.includes('pipeline') ||
+        sourceFiles.includes('etl') ||
+        sourceFiles.includes('dag') ||
+        sourceFiles.includes('airflow')) {
+        signals.push({
+            name: 'has-etl-pipeline-keywords',
+            source: 'code-scanner',
+            weight: 4,
+        });
+    }
+    // Mobile configs
+    if (infraFiles.includes('info.plist') ||
+        infraFiles.includes('androidmanifest.xml') ||
+        configFiles.includes('build.gradle')) {
+        signals.push({
+            name: 'has-mobile-configs',
+            source: 'file-scanner',
+            weight: 5,
+        });
+    }
+    // Third-party API clients (no routes)
+    if ((sourceFiles.includes('client') || sourceFiles.includes('adapter')) &&
+        !sourceFiles.includes('routes')) {
+        if (allFiles.includes('axios') ||
+            allFiles.includes('fetch') ||
+            allFiles.includes('requests') ||
+            allFiles.includes('httpx')) {
+            signals.push({
+                name: 'has-third-party-api-clients',
+                source: 'code-scanner',
+                weight: 3,
+            });
+        }
+    }
+    // Compliance signals
+    const complianceText = allFiles.toLowerCase();
+    if (complianceText.includes('hipaa') ||
+        complianceText.includes('sox') ||
+        complianceText.includes('pci')) {
+        signals.push({
+            name: 'has-compliance-requirements',
+            source: 'artifact-scanner',
+            weight: 5,
+        });
+    }
+    // RBAC/MultiTenant
+    if (sourceFiles.includes('rbac') ||
+        sourceFiles.includes('tenant') ||
+        sourceFiles.includes('permission') ||
+        sourceFiles.includes('role')) {
+        signals.push({
+            name: 'has-rbac-tenant-patterns',
+            source: 'code-scanner',
+            weight: 3,
+        });
+    }
+    // SLA/Uptime signals
+    if (docFiles.includes('sla') ||
+        sourceFiles.includes('uptime') ||
+        sourceFiles.includes('metrics') ||
+        sourceFiles.includes('monitoring')) {
+        signals.push({
+            name: 'has-sla-uptime-mentions',
+            source: 'artifact-scanner',
+            weight: 3,
+        });
+    }
+    // Internal/Tooling signals
+    if (sourceFiles.includes('admin') ||
+        sourceFiles.includes('internal') ||
+        sourceFiles.includes('tool') ||
+        sourceFiles.includes('utility')) {
+        signals.push({
+            name: 'has-internal-tooling',
+            source: 'code-scanner',
+            weight: 3,
+        });
+    }
+    // Test coverage signal
+    if (inventory.categories.tests.count > 0) {
+        signals.push({
+            name: 'has-tests',
+            source: 'file-scanner',
+            weight: 2,
+        });
+    }
+    // API spec signal
+    if (configFiles.includes('swagger') || configFiles.includes('openapi')) {
+        signals.push({
+            name: 'has-api-spec',
+            source: 'file-scanner',
+            weight: 3,
+        });
+    }
+    // Microservices patterns
+    if (sourceFiles.includes('service') && sourceFiles.includes('message')) {
+        signals.push({
+            name: 'has-microservices-pattern',
+            source: 'code-scanner',
+            weight: 2,
+        });
+    }
+    // Database/ORM signals
+    if (allFiles.includes('prisma') ||
+        allFiles.includes('typeorm') ||
+        allFiles.includes('sqlalchemy') ||
+        allFiles.includes('mongoose')) {
+        signals.push({
+            name: 'has-database-orm',
+            source: 'code-scanner',
+            weight: 2,
+        });
+    }
+    // Monitoring/Logging
+    if (allFiles.includes('prometheus') ||
+        allFiles.includes('grafana') ||
+        allFiles.includes('datadog') ||
+        allFiles.includes('sentry') ||
+        allFiles.includes('winston') ||
+        allFiles.includes('pino')) {
+        signals.push({
+            name: 'has-monitoring-logging',
+            source: 'code-scanner',
+            weight: 2,
+        });
+    }
+    // New 626Labs-specific signals
+    // Firebase/Firestore
+    if (configFiles.includes('firebase') || allFiles.includes('firestore') || allFiles.includes('firebase')) {
+        signals.push({
+            name: 'has-firebase',
+            source: 'file-scanner',
+            weight: 3,
+        });
+    }
+    // Vite config
+    if (configFiles.includes('vite.config')) {
+        signals.push({
+            name: 'has-vite-config',
+            source: 'file-scanner',
+            weight: 2,
+        });
+    }
+    // Tailwind CSS
+    if (configFiles.includes('tailwind')) {
+        signals.push({
+            name: 'has-tailwind',
+            source: 'file-scanner',
+            weight: 1,
+        });
+    }
+    // Next.js / Nuxt
+    if (configFiles.includes('next.config') || configFiles.includes('nuxt.config')) {
+        signals.push({
+            name: 'has-nextjs-nuxt',
+            source: 'file-scanner',
+            weight: 4,
+        });
+    }
+    // Cloud Functions
+    if (sourceFiles.includes('functions/')) {
+        signals.push({
+            name: 'has-cloud-functions',
+            source: 'file-scanner',
+            weight: 3,
+        });
+    }
+    // AI SDK
+    if (allFiles.includes('genkit') || allFiles.includes('@ai-sdk')) {
+        signals.push({
+            name: 'has-ai-sdk',
+            source: 'code-scanner',
+            weight: 3,
+        });
+    }
+    // MCP Server
+    if (sourceFiles.includes('mcp-server') || allFiles.includes('mcp')) {
+        signals.push({
+            name: 'has-mcp-server',
+            source: 'file-scanner',
+            weight: 2,
+        });
+    }
+    // State Management
+    if (allFiles.includes('zustand') || allFiles.includes('redux')) {
+        signals.push({
+            name: 'has-state-management',
+            source: 'code-scanner',
+            weight: 2,
+        });
+    }
+    // E2E Testing
+    if (allFiles.includes('playwright') || allFiles.includes('cypress')) {
+        signals.push({
+            name: 'has-e2e-testing',
+            source: 'file-scanner',
+            weight: 0.5,
+        });
+    }
+    // GitHub Actions
+    if (configFiles.includes('.github/workflows')) {
+        signals.push({
+            name: 'has-github-actions',
+            source: 'file-scanner',
+            weight: 1,
+        });
+    }
+    logger_1.logger.debug(`Extracted ${signals.length} signals from inventory`);
+    return signals;
+}

package/dist/gap-analyzer/breadcrumbs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Breadcrumbs Module
+ * Search heuristics for finding evidence of documentation in artifacts
+ */
+export interface Breadcrumb {
+    docType: string;
+    keywords: string[];
+    filePatterns: string[];
+    gitPatterns: string[];
+    codePatterns: string[];
+    requiredSections: string[];
+    gapQuestions: string[];
+}
+/**
+ * Get breadcrumbs for a specific doc type
+ */
+export declare function getBreadcrumbs(docType: string): Breadcrumb;
+//# sourceMappingURL=breadcrumbs.d.ts.map

package/dist/gap-analyzer/breadcrumbs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breadcrumbs.d.ts","sourceRoot":"","sources":["../../src/gap-analyzer/breadcrumbs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAsT1D"}