@esthernandez/vibe-doc 0.1.0

package/dist/checker/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * CI Check Logic
+ * Validates that all required documentation exists and is not stale
+ */
+export interface CheckOptions {
+    threshold?: number;
+}
+export interface CheckResult {
+    pass: boolean;
+    missing: string[];
+    stale: string[];
+    details: string;
+    exitCode: 0 | 1;
+}
+/**
+ * Run CI checks on the project
+ * Verifies that all required docs exist and are not stale
+ * @param projectPath - Root path of the project
+ * @param options - Check options (threshold in commits)
+ * @returns CheckResult with pass/fail status and details
+ */
+export declare function runCheck(projectPath: string, options?: CheckOptions): Promise<CheckResult>;
+/**
+ * Get detailed staleness info for a specific doc type
+ * Useful for debugging/verbose output
+ */
+export declare function getDocStalenessDetails(projectPath: string, docType: string): Promise<{
+    docType: string;
+    commitsSince: number;
+    daysSince: number;
+    generatedAt: string;
+    exists: boolean;
+} | null>;
+//# sourceMappingURL=index.d.ts.map

package/dist/checker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/checker/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAC5B,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,WAAW,CAAC,CAyDtB;AAqCD;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IACT,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;CACjB,GAAG,IAAI,CAAC,CA0BR"}

package/dist/checker/index.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * CI Check Logic
+ * Validates that all required documentation exists and is not stale
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCheck = runCheck;
+exports.getDocStalenessDetails = getDocStalenessDetails;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const state_1 = require("../state");
+const staleness_1 = require("./staleness");
+/**
+ * Run CI checks on the project
+ * Verifies that all required docs exist and are not stale
+ * @param projectPath - Root path of the project
+ * @param options - Check options (threshold in commits)
+ * @returns CheckResult with pass/fail status and details
+ */
+async function runCheck(projectPath, options = {}) {
+    const threshold = options.threshold ?? 20;
+    const missing = [];
+    const stale = [];
+    // Read state
+    const state = (0, state_1.readState)(projectPath);
+    if (!state) {
+        return {
+            pass: false,
+            missing: [],
+            stale: [],
+            details: 'No vibe-doc state found. Run `vibe-doc scan` first.',
+            exitCode: 1,
+        };
+    }
+    // Get all required gaps (tier === 'required')
+    const requiredGaps = state.gapReport.gaps.filter((gap) => gap.tier === 'required');
+    // Check each required gap
+    for (const gap of requiredGaps) {
+        const docPath = path.join(projectPath, 'docs', 'generated', `${gap.docType}.md`);
+        // Check if doc exists
+        if (!fs.existsSync(docPath)) {
+            missing.push(gap.docType);
+            continue;
+        }
+        // Find the generated doc in state
+        const generatedDoc = state.generatedDocs.find((d) => d.docType === gap.docType);
+        if (!generatedDoc) {
+            missing.push(gap.docType);
+            continue;
+        }
+        // Check staleness
+        const docIsStale = await (0, staleness_1.isStale)(generatedDoc, projectPath, threshold);
+        if (docIsStale) {
+            stale.push(gap.docType);
+        }
+    }
+    // Determine pass/fail
+    const pass = missing.length === 0 && stale.length === 0;
+    // Build details message
+    const details = buildDetailsMessage(requiredGaps.length, missing, stale, threshold);
+    return {
+        pass,
+        missing,
+        stale,
+        details,
+        exitCode: pass ? 0 : 1,
+    };
+}
+/**
+ * Build a human-readable details message
+ */
+function buildDetailsMessage(totalRequired, missing, stale, threshold) {
+    const lines = [];
+    lines.push(`Documentation Check Results`);
+    lines.push(`Required docs: ${totalRequired}`);
+    if (missing.length > 0) {
+        lines.push(`\nMissing (${missing.length}):`);
+        for (const doc of missing) {
+            lines.push(`  - ${doc}`);
+        }
+    }
+    if (stale.length > 0) {
+        lines.push(`\nStale - more than ${threshold} commits since generation (${stale.length}):`);
+        for (const doc of stale) {
+            lines.push(`  - ${doc}`);
+        }
+    }
+    if (missing.length === 0 && stale.length === 0) {
+        lines.push(`\n✓ All required documentation is present and current`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Get detailed staleness info for a specific doc type
+ * Useful for debugging/verbose output
+ */
+async function getDocStalenessDetails(projectPath, docType) {
+    const state = (0, state_1.readState)(projectPath);
+    if (!state) {
+        return null;
+    }
+    const generatedDoc = state.generatedDocs.find((d) => d.docType === docType);
+    if (!generatedDoc) {
+        return null;
+    }
+    const docPath = path.join(projectPath, 'docs', 'generated', `${docType}.md`);
+    const exists = fs.existsSync(docPath);
+    try {
+        const staleness = await (0, staleness_1.getStalenessInfo)(generatedDoc, projectPath);
+        return {
+            docType,
+            commitsSince: staleness.commitsSince,
+            daysSince: staleness.daysSince,
+            generatedAt: generatedDoc.generatedAt,
+            exists,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/checker/staleness.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Staleness Detection
+ * Determines if generated documentation is stale based on git commit history
+ */
+import { GeneratedDoc } from '../state/schema';
+export interface StalenessInfo {
+    commitsSince: number;
+    daysSince: number;
+    isStale: boolean;
+}
+/**
+ * Check if a document is stale based on commit count since generation
+ * @param doc - The generated document
+ * @param projectPath - Root path of the project
+ * @param threshold - Number of commits before doc is considered stale (default: 20)
+ * @returns true if commits since generation >= threshold
+ */
+export declare function isStale(doc: GeneratedDoc, projectPath: string, threshold?: number): Promise<boolean>;
+/**
+ * Get detailed staleness information for a document
+ * @param doc - The generated document
+ * @param projectPath - Root path of the project
+ * @returns Staleness info including commit count and days since generation
+ */
+export declare function getStalenessInfo(doc: GeneratedDoc, projectPath: string): Promise<StalenessInfo>;
+//# sourceMappingURL=staleness.d.ts.map

package/dist/checker/staleness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staleness.d.ts","sourceRoot":"","sources":["../../src/checker/staleness.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,YAAY,EACjB,WAAW,EAAE,MAAM,EACnB,SAAS,GAAE,MAAW,GACrB,OAAO,CAAC,OAAO,CAAC,CAWlB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,YAAY,EACjB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,aAAa,CAAC,CAsBxB"}

package/dist/checker/staleness.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Staleness Detection
+ * Determines if generated documentation is stale based on git commit history
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStale = isStale;
+exports.getStalenessInfo = getStalenessInfo;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * Check if a document is stale based on commit count since generation
+ * @param doc - The generated document
+ * @param projectPath - Root path of the project
+ * @param threshold - Number of commits before doc is considered stale (default: 20)
+ * @returns true if commits since generation >= threshold
+ */
+async function isStale(doc, projectPath, threshold = 20) {
+    try {
+        const staleness = await getStalenessInfo(doc, projectPath);
+        return staleness.commitsSince >= threshold;
+    }
+    catch (error) {
+        // If we can't determine staleness, conservatively assume stale to prevent deploying with outdated docs
+        console.warn(`Failed to check staleness for ${doc.docType}: ${error}. Assuming stale for safety.`);
+        return true;
+    }
+}
+/**
+ * Get detailed staleness information for a document
+ * @param doc - The generated document
+ * @param projectPath - Root path of the project
+ * @returns Staleness info including commit count and days since generation
+ */
+async function getStalenessInfo(doc, projectPath) {
+    try {
+        const git = (0, simple_git_1.default)(projectPath);
+        // Get the timestamp of the document generation
+        const docDate = new Date(doc.generatedAt);
+        // Get all commits since that time
+        const log = await git.log({ from: doc.generatedAt });
+        // Calculate days since generation
+        const now = new Date();
+        const daysSince = Math.floor((now.getTime() - docDate.getTime()) / (1000 * 60 * 60 * 24));
+        return {
+            commitsSince: log.total,
+            daysSince,
+            isStale: false, // Will be set by isStale() function
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to get staleness info for ${doc.docType}: ${error}`);
+    }
+}

package/dist/classifier/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Classifier Orchestrator
+ * Main entry point for hybrid classification
+ */
+import { ArtifactInventory, Classification } from '../state/schema';
+export interface ClassificationOptions {
+    confidenceThreshold?: number;
+}
+export interface ClassificationResult {
+    resolved: boolean;
+    classification?: Classification;
+    llmPrompt?: string;
+    candidates?: Array<{
+        category: string;
+        score: number;
+    }>;
+    contexts?: string[];
+}
+/**
+ * Classify a project based on artifact inventory
+ * Returns either a high-confidence classification or a prompt for LLM fallback
+ * @param inventory - Artifact inventory from scanner
+ * @param options - Classification options (confidenceThreshold, etc.)
+ */
+export declare function classify(inventory: ArtifactInventory, options?: ClassificationOptions): ClassificationResult;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/classifier/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAqB,MAAM,iBAAiB,CAAC;AAMvF,MAAM,WAAW,qBAAqB;IACpC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,oBAAoB,CAkDtB"}

package/dist/classifier/index.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Classifier Orchestrator
+ * Main entry point for hybrid classification
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classify = classify;
+const logger_1 = require("../utils/logger");
+const signals_1 = require("./signals");
+const scoring_engine_1 = require("./scoring-engine");
+const llm_prompt_1 = require("./llm-prompt");
+/**
+ * Classify a project based on artifact inventory
+ * Returns either a high-confidence classification or a prompt for LLM fallback
+ * @param inventory - Artifact inventory from scanner
+ * @param options - Classification options (confidenceThreshold, etc.)
+ */
+function classify(inventory, options) {
+    const confidenceThreshold = options?.confidenceThreshold ?? 0.85;
+    logger_1.logger.info('Starting hybrid classification', { confidenceThreshold });
+    // Step 1: Extract signals from inventory
+    const signals = (0, signals_1.extractSignals)(inventory);
+    logger_1.logger.info('Signals extracted', { count: signals.length });
+    // Step 2: Run scoring engine
+    const ruleResults = (0, scoring_engine_1.scoreClassification)(signals, confidenceThreshold);
+    logger_1.logger.info('Rule-based scoring complete', {
+        confidence: ruleResults.confidence,
+        topCategory: ruleResults.categories[0],
+    });
+    // Step 3: Check confidence threshold
+    if (ruleResults.confidence >= confidenceThreshold) {
+        // High confidence - return classification directly
+        const classification = buildClassification(ruleResults, inventory);
+        logger_1.logger.info('Classification resolved with high confidence', {
+            category: classification.primaryCategory,
+            confidence: classification.confidence,
+        });
+        return {
+            resolved: true,
+            classification,
+        };
+    }
+    // Low confidence - build classification from best candidate and prepare LLM prompt
+    logger_1.logger.info('Classification confidence too low, building from best candidate', {
+        confidence: ruleResults.confidence,
+        topCandidate: ruleResults.categories[0]?.category,
+    });
+    const llmPrompt = (0, llm_prompt_1.buildClassificationPrompt)(inventory, ruleResults);
+    const classification = buildLowConfidenceClassification(ruleResults, inventory);
+    return {
+        resolved: false,
+        classification,
+        llmPrompt,
+        candidates: ruleResults.categories.map((c) => ({
+            category: c.category,
+            score: c.score,
+        })),
+        contexts: ruleResults.contexts.map((c) => c.context),
+    };
+}
+/**
+ * Build a Classification object from scoring results
+ */
+function buildClassification(ruleResults, inventory) {
+    const topCategory = ruleResults.categories[0];
+    const secondaryCategory = ruleResults.categories.length > 1 ? ruleResults.categories[1] : null;
+    const contexts = ruleResults.contexts.map((c) => c.context);
+    // Map category to deployment context
+    const deploymentContext = mapCategoryToDeploymentContext(topCategory.category, contexts);
+    return {
+        primaryCategory: topCategory.category,
+        secondaryCategory: secondaryCategory?.category || '',
+        deploymentContext,
+        contextModifiers: contexts,
+        confidence: ruleResults.confidence,
+        rationale: buildRationale(topCategory.category, contexts),
+        userConfirmed: false,
+    };
+}
+/**
+ * Build a Classification object from low-confidence scoring results
+ * Uses the best candidate with actual confidence score and contexts
+ */
+function buildLowConfidenceClassification(ruleResults, inventory) {
+    const topCategory = ruleResults.categories[0];
+    const secondaryCategory = ruleResults.categories.length > 1 ? ruleResults.categories[1] : null;
+    const contexts = ruleResults.contexts.map((c) => c.context);
+    // Map category to deployment context
+    const deploymentContext = mapCategoryToDeploymentContext(topCategory.category, contexts);
+    // Build rationale noting that LLM review is available
+    const baseRationale = buildRationale(topCategory.category, contexts);
+    const reviewNote = ' [LLM review available to increase confidence]';
+    return {
+        primaryCategory: topCategory.category,
+        secondaryCategory: secondaryCategory?.category || '',
+        deploymentContext,
+        contextModifiers: contexts,
+        confidence: ruleResults.confidence,
+        rationale: baseRationale + reviewNote,
+        userConfirmed: false,
+    };
+}
+/**
+ * Map category and contexts to deployment context
+ */
+function mapCategoryToDeploymentContext(category, contexts) {
+    const result = [];
+    // Determine platform based on category
+    let platform = 'cloud';
+    if (category === scoring_engine_1.Category.MobileApplication) {
+        platform = 'mobile';
+    }
+    else if (category === scoring_engine_1.Category.InfrastructurePlatform) {
+        platform = 'kubernetes';
+    }
+    // Check for EdgeEmbedded context
+    if (contexts.includes(scoring_engine_1.Context.EdgeEmbedded)) {
+        platform = 'edge';
+    }
+    // Determine environment based on contexts
+    let environment = 'production';
+    if (contexts.includes(scoring_engine_1.Context.InternalTooling)) {
+        environment = 'staging';
+    }
+    // Determine scale based on contexts
+    let scale = 'small';
+    if (contexts.includes(scoring_engine_1.Context.CustomerFacing)) {
+        scale = 'large';
+    }
+    else if (contexts.includes(scoring_engine_1.Context.MultiTenant)) {
+        scale = 'large';
+    }
+    result.push({ platform, environment, scale });
+    return result;
+}
+/**
+ * Build a rationale string for the classification
+ */
+function buildRationale(category, contexts) {
+    const parts = [];
+    parts.push(`Primary category: ${category}`);
+    if (contexts.length > 0) {
+        parts.push(`Contexts: ${contexts.join(', ')}`);
+    }
+    return parts.join('. ');
+}

package/dist/classifier/llm-prompt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * LLM Prompt Builder
+ * Generates structured prompts for LLM-based classification fallback
+ */
+import { ArtifactInventory } from '../state/schema';
+import { ScoringResult } from './scoring-engine';
+/**
+ * Build a structured prompt for LLM classification
+ * Used when rule-based confidence is < 0.85
+ */
+export declare function buildClassificationPrompt(inventory: ArtifactInventory, ruleResults: ScoringResult): string;
+//# sourceMappingURL=llm-prompt.d.ts.map

package/dist/classifier/llm-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-prompt.d.ts","sourceRoot":"","sources":["../../src/classifier/llm-prompt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAA+B,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE9E;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,iBAAiB,EAC5B,WAAW,EAAE,aAAa,GACzB,MAAM,CA0DR"}

package/dist/classifier/llm-prompt.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * LLM Prompt Builder
+ * Generates structured prompts for LLM-based classification fallback
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClassificationPrompt = buildClassificationPrompt;
+/**
+ * Build a structured prompt for LLM classification
+ * Used when rule-based confidence is < 0.85
+ */
+function buildClassificationPrompt(inventory, ruleResults) {
+    const topCategories = ruleResults.categories.slice(0, 3);
+    const detectedContexts = ruleResults.contexts.slice(0, 3);
+    const projectSummary = buildProjectSummary(inventory);
+    const candidateSummary = buildCandidateSummary(topCategories, detectedContexts);
+    return `# Project Classification Task
+
+You are an expert software architect reviewing a codebase to determine its primary category and operational contexts.
+
+## Project Scan Summary
+
+${projectSummary}
+
+## Rule Engine Candidates
+
+The rule-based classifier generated these candidates with confidence ${(ruleResults.confidence * 100).toFixed(0)}%:
+
+${candidateSummary}
+
+## Classification Categories
+
+Choose ONE primary category that best describes this project:
+
+- **WebApplication**: A user-facing web application (SPA, server-rendered, etc.)
+- **APIMicroservice**: A REST API, GraphQL service, or microservice
+- **DataPipeline**: ETL pipelines, data warehouses, batch processors
+- **InfrastructurePlatform**: Infrastructure-as-code, deployment systems, cloud platforms
+- **MobileApplication**: Native or cross-platform mobile apps
+- **AIMLSystem**: ML/AI-focused projects with models, training, inference
+- **IntegrationConnector**: Adapters, SDKs, connectors for third-party services
+
+## Operational Contexts
+
+Identify applicable contexts (can select multiple):
+
+- **Regulated**: Subject to compliance requirements (HIPAA, SOX, PCI, etc.)
+- **CustomerFacing**: Public-facing or customer-critical service
+- **InternalTooling**: Internal tools, admin dashboards, support systems
+- **MultiTenant**: Serves multiple independent customers/tenants
+- **EdgeEmbedded**: Runs on edge devices, embedded systems, or IoT
+
+## Your Response
+
+Return a JSON object with this exact structure:
+\`\`\`json
+{
+  "primaryCategory": "string (one of the categories above)",
+  "secondaryCategory": "string (optional, for ambiguous cases)",
+  "contexts": ["string", "string"],
+  "confidence": 0.75,
+  "rationale": "Explain your classification in 2-3 sentences"
+}
+\`\`\`
+
+Focus on the strongest signals in the codebase. If multiple categories are equally plausible, explain the tie-breaker in rationale.
+`;
+}
+function buildProjectSummary(inventory) {
+    const sc = inventory.categories.sourceCode;
+    const conf = inventory.categories.configuration;
+    const doc = inventory.categories.documentation;
+    const tests = inventory.categories.tests;
+    const arch = inventory.categories.architecture;
+    const infra = inventory.categories.infrastructure;
+    const languages = inventory.gitStats.mainLanguages.slice(0, 5).join(', ') || 'Unknown';
+    return `
+### File Distribution
+- Source code: ${sc.count} files (${languages})
+- Configuration: ${conf.count} files
+- Documentation: ${doc.count} files
+- Tests: ${tests.count} files
+- Architecture artifacts: ${arch.count} files
+- Infrastructure: ${infra.count} files
+- **Total artifacts: ${inventory.totalArtifacts}**
+
+### Git Activity
+- Total commits: ${inventory.gitStats.totalCommits}
+- Contributors: ${inventory.gitStats.contributors}
+- Last commit: ${inventory.gitStats.lastCommitDate}
+
+### Top Source Files (Sample)
+\`\`\`
+${sc.files.slice(0, 5).join('\n')}
+${sc.files.length > 5 ? `... and ${sc.files.length - 5} more source files` : ''}
+\`\`\`
+
+### Configuration Files (Sample)
+\`\`\`
+${conf.files.slice(0, 5).join('\n')}
+${conf.files.length > 5 ? `... and ${conf.files.length - 5} more config files` : ''}
+\`\`\`
+
+### Infrastructure Files (Sample)
+\`\`\`
+${infra.files.slice(0, 5).join('\n')}
+${infra.files.length > 5 ? `... and ${infra.files.length - 5} more infrastructure files` : ''}
+\`\`\`
+`;
+}
+function buildCandidateSummary(categories, contexts) {
+    let summary = '### Categories (Rule Score)\n';
+    for (const cat of categories) {
+        summary += `- ${cat.category}: ${cat.score.toFixed(1)}\n`;
+    }
+    if (contexts.length > 0) {
+        summary += '\n### Detected Contexts (Rule Score)\n';
+        for (const ctx of contexts) {
+            summary += `- ${ctx.context}: ${ctx.score.toFixed(1)}\n`;
+        }
+    }
+    return summary;
+}

package/dist/classifier/scoring-engine.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Scoring Engine Module
+ * Rule-based matrix for categorizing projects and contexts
+ */
+import { Signal } from './signals';
+export declare enum Category {
+    WebApplication = "WebApplication",
+    APIMicroservice = "APIMicroservice",
+    DataPipeline = "DataPipeline",
+    InfrastructurePlatform = "InfrastructurePlatform",
+    MobileApplication = "MobileApplication",
+    AIMLSystem = "AIMLSystem",
+    IntegrationConnector = "IntegrationConnector"
+}
+export declare enum Context {
+    Regulated = "Regulated",
+    CustomerFacing = "CustomerFacing",
+    InternalTooling = "InternalTooling",
+    MultiTenant = "MultiTenant",
+    EdgeEmbedded = "EdgeEmbedded"
+}
+export interface CategoryScore {
+    category: Category;
+    score: number;
+}
+export interface ContextScore {
+    context: Context;
+    score: number;
+}
+export interface ScoringResult {
+    categories: CategoryScore[];
+    contexts: ContextScore[];
+    confidence: number;
+}
+/**
+ * Score classification based on signals
+ * @param signals - Array of detected signals
+ * @param confidenceThreshold - Threshold for high confidence classification (default: 0.85)
+ */
+export declare function scoreClassification(signals: Signal[], confidenceThreshold?: number): ScoringResult;
+//# sourceMappingURL=scoring-engine.d.ts.map

package/dist/classifier/scoring-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoring-engine.d.ts","sourceRoot":"","sources":["../../src/classifier/scoring-engine.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGnC,oBAAY,QAAQ;IAClB,cAAc,mBAAmB;IACjC,eAAe,oBAAoB;IACnC,YAAY,iBAAiB;IAC7B,sBAAsB,2BAA2B;IACjD,iBAAiB,sBAAsB;IACvC,UAAU,eAAe;IACzB,oBAAoB,yBAAyB;CAC9C;AAED,oBAAY,OAAO;IACjB,SAAS,cAAc;IACvB,cAAc,mBAAmB;IACjC,eAAe,oBAAoB;IACnC,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EAAE,EACjB,mBAAmB,GAAE,MAAa,GACjC,aAAa,CAuMf"}