@esthernandez/vibe-doc 0.1.0

package/dist/scanner/code-scanner.d.ts

@@ -0,0 +1,17 @@
+import { DetectedLanguage } from '../utils/language-detect';
+export interface CodeStructure {
+    languages: DetectedLanguage[];
+    entryPoints: {
+        [language: string]: string[];
+    };
+    routeHandlers: {
+        [language: string]: string[];
+    };
+    models: {
+        [language: string]: string[];
+    };
+    testDirectories: string[];
+    packageConfigs: string[];
+}
+export declare function scanCode(projectPath: string): Promise<CodeStructure>;
+//# sourceMappingURL=code-scanner.d.ts.map

package/dist/scanner/code-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-scanner.d.ts","sourceRoot":"","sources":["../../src/scanner/code-scanner.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAE7E,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,WAAW,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC;IAC9C,aAAa,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC;IAChD,MAAM,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC;IACzC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAYD,wBAAsB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAoB1E"}

package/dist/scanner/code-scanner.js

@@ -0,0 +1,69 @@
+"use strict";
+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.scanCode = scanCode;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fast_glob_1 = require("fast-glob");
+const logger_1 = require("../utils/logger");
+const language_detect_1 = require("../utils/language-detect");
+async function findPackageConfigs(projectPath) {
+    const cfgs = await (0, fast_glob_1.glob)(['package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod'], { cwd: projectPath });
+    return cfgs.map(c => path.join(projectPath, c)).filter(c => fs.existsSync(c));
+}
+async function findTestDirectories(projectPath) {
+    const dirs = await (0, fast_glob_1.glob)(['__tests__', 'tests', 'test'], { cwd: projectPath, onlyDirectories: true });
+    return dirs.map(d => path.join(projectPath, d)).filter(d => fs.existsSync(d));
+}
+async function scanCode(projectPath) {
+    try {
+        const packageConfigs = await findPackageConfigs(projectPath);
+        const languages = (0, language_detect_1.detectLanguages)(packageConfigs);
+        const testDirectories = await findTestDirectories(projectPath);
+        logger_1.logger.info('Code scan completed', { languages: languages.length });
+        return {
+            languages,
+            entryPoints: {},
+            routeHandlers: {},
+            models: {},
+            testDirectories,
+            packageConfigs,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error('Code scan failed', { error });
+        throw error;
+    }
+}

package/dist/scanner/file-scanner.d.ts

@@ -0,0 +1,16 @@
+import { ArtifactsByType } from '../state/schema';
+interface FileScanResult {
+    configAsDocs: ArtifactsByType;
+    agentArtifacts: ArtifactsByType;
+    sessionContext: ArtifactsByType;
+    documentation: ArtifactsByType;
+    packageConfigs: ArtifactsByType;
+    cicdConfigs: ArtifactsByType;
+    infrastructure: ArtifactsByType;
+    testFiles: ArtifactsByType;
+    apiSpecs: ArtifactsByType;
+    sourceCode: ArtifactsByType;
+}
+export declare function scanFiles(projectPath: string): Promise<FileScanResult>;
+export {};
+//# sourceMappingURL=file-scanner.d.ts.map

package/dist/scanner/file-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-scanner.d.ts","sourceRoot":"","sources":["../../src/scanner/file-scanner.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,UAAU,cAAc;IACtB,YAAY,EAAE,eAAe,CAAC;IAC9B,cAAc,EAAE,eAAe,CAAC;IAChC,cAAc,EAAE,eAAe,CAAC;IAChC,aAAa,EAAE,eAAe,CAAC;IAC/B,cAAc,EAAE,eAAe,CAAC;IAChC,WAAW,EAAE,eAAe,CAAC;IAC7B,cAAc,EAAE,eAAe,CAAC;IAChC,SAAS,EAAE,eAAe,CAAC;IAC3B,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,eAAe,CAAC;CAC7B;AA8CD,wBAAsB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CA2B5E"}

package/dist/scanner/file-scanner.js

@@ -0,0 +1,119 @@
+"use strict";
+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.scanFiles = scanFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+const EXCLUDE_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', 'coverage', '.next', 'venv', '.venv',
+    '__pycache__', 'target', '.cache', '.turbo', 'temp', 'tmp', '.pytest_cache',
+    'jest_cache', '.eslintcache', '.nuxt', '.parcel-cache', 'bower_components'
+]);
+function categorizeFile(filePath) {
+    const n = filePath.replace(/\\/g, '/');
+    if (n.endsWith('CLAUDE.md'))
+        return 'configAsDocs';
+    if (n.includes('/.ai/') || n.includes('/.agent/skills/'))
+        return 'agentArtifacts';
+    if (n.includes('/.claude/'))
+        return 'sessionContext';
+    if (n.includes('/docs/') && n.endsWith('.md'))
+        return 'documentation';
+    if (n.endsWith('package.json') || n.endsWith('Cargo.toml'))
+        return 'packageConfigs';
+    if (n.includes('/.github/workflows/'))
+        return 'cicdConfigs';
+    if (n.endsWith('Dockerfile') || n.endsWith('.tf'))
+        return 'infrastructure';
+    if (n.match(/\.(test|spec)\.[jt]sx?$/))
+        return 'testFiles';
+    if (n.endsWith('swagger.json'))
+        return 'apiSpecs';
+    return 'sourceCode';
+}
+function walkDir(dir, maxDepth = 4, currentDepth = 0) {
+    const files = [];
+    if (currentDepth > maxDepth)
+        return files;
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (EXCLUDE_DIRS.has(entry.name))
+                continue;
+            if (entry.name.startsWith('.') && entry.name !== '.ai' && entry.name !== '.agent' && entry.name !== '.claude' && entry.name !== '.github')
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isFile()) {
+                files.push(fullPath);
+            }
+            else if (entry.isDirectory()) {
+                files.push(...walkDir(fullPath, maxDepth, currentDepth + 1));
+            }
+        }
+    }
+    catch (error) {
+        logger_1.logger.warn('Failed to read directory', { dir, error });
+    }
+    return files;
+}
+async function scanFiles(projectPath) {
+    const result = {
+        configAsDocs: { files: [], count: 0 },
+        agentArtifacts: { files: [], count: 0 },
+        sessionContext: { files: [], count: 0 },
+        documentation: { files: [], count: 0 },
+        packageConfigs: { files: [], count: 0 },
+        cicdConfigs: { files: [], count: 0 },
+        infrastructure: { files: [], count: 0 },
+        testFiles: { files: [], count: 0 },
+        apiSpecs: { files: [], count: 0 },
+        sourceCode: { files: [], count: 0 },
+    };
+    try {
+        const files = walkDir(projectPath);
+        for (const file of files) {
+            const cat = categorizeFile(file);
+            result[cat].files.push(file);
+            result[cat].count++;
+        }
+        logger_1.logger.info('File scan completed', { total: files.length });
+        return result;
+    }
+    catch (error) {
+        logger_1.logger.error('File scan failed', { error });
+        throw error;
+    }
+}

package/dist/scanner/git-scanner.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Git Scanner
+ * Extracts git statistics from a repository
+ */
+import { GitStats } from '../state/schema';
+/**
+ * Scans git repository for statistics
+ */
+export declare function scanGit(projectPath: string): Promise<GitStats>;
+//# sourceMappingURL=git-scanner.d.ts.map

package/dist/scanner/git-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-scanner.d.ts","sourceRoot":"","sources":["../../src/scanner/git-scanner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAiE3C;;GAEG;AACH,wBAAsB,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuEpE"}

package/dist/scanner/git-scanner.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Git Scanner
+ * Extracts git statistics from a repository
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanGit = scanGit;
+const simple_git_1 = require("simple-git");
+const logger_1 = require("../utils/logger");
+/**
+ * Analyzes commit messages for conventional commit format
+ */
+function analyzeConventionalCommits(messages) {
+    const patterns = {
+        feat: 0,
+        fix: 0,
+        refactor: 0,
+        docs: 0,
+        chore: 0,
+        other: 0,
+    };
+    let validConventional = 0;
+    for (const message of messages) {
+        const lines = message.split('\n');
+        const firstLine = lines[0];
+        if (firstLine.match(/^feat(\(.+\))?:/)) {
+            patterns.feat++;
+            validConventional++;
+        }
+        else if (firstLine.match(/^fix(\(.+\))?:/)) {
+            patterns.fix++;
+            validConventional++;
+        }
+        else if (firstLine.match(/^refactor(\(.+\))?:/)) {
+            patterns.refactor++;
+            validConventional++;
+        }
+        else if (firstLine.match(/^docs(\(.+\))?:/)) {
+            patterns.docs++;
+            validConventional++;
+        }
+        else if (firstLine.match(/^chore(\(.+\))?:/)) {
+            patterns.chore++;
+            validConventional++;
+        }
+        else {
+            patterns.other++;
+        }
+    }
+    const rate = messages.length > 0 ? validConventional / messages.length : 0;
+    return { rate, patterns };
+}
+/**
+ * Scans git repository for statistics
+ */
+async function scanGit(projectPath) {
+    logger_1.logger.debug('Starting git scan', { projectPath });
+    try {
+        const git = (0, simple_git_1.simpleGit)(projectPath);
+        // Check if it's a git repository
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            logger_1.logger.warn('Not a git repository', { projectPath });
+            return {
+                totalCommits: 0,
+                contributors: 0,
+                lastCommitDate: '',
+                mainLanguages: [],
+            };
+        }
+        // Get commit count
+        const log = await git.log();
+        const totalCommits = log.total || 0;
+        logger_1.logger.debug('Total commits', { count: totalCommits });
+        // Get unique contributors
+        const logWithAuthor = await git.log(['--format=%an']);
+        const authors = logWithAuthor.all
+            .map((commit) => commit.message)
+            .filter((author) => author.length > 0);
+        const uniqueAuthors = new Set(authors);
+        const contributors = uniqueAuthors.size;
+        logger_1.logger.debug('Unique contributors', { count: contributors });
+        // Get last commit date
+        let lastCommitDate = '';
+        if (log.latest) {
+            lastCommitDate = log.latest.date || '';
+        }
+        logger_1.logger.debug('Last commit date', { date: lastCommitDate });
+        // Analyze conventional commits (sample for performance)
+        const commitMessages = [];
+        const sampleSize = Math.min(100, totalCommits);
+        for (let i = 0; i < sampleSize; i++) {
+            if (log.all[i]) {
+                commitMessages.push(log.all[i].message);
+            }
+        }
+        const { patterns } = analyzeConventionalCommits(commitMessages);
+        logger_1.logger.info('Git scan completed', {
+            totalCommits,
+            contributors,
+            lastCommitDate,
+            commitPatterns: patterns,
+        });
+        return {
+            totalCommits,
+            contributors,
+            lastCommitDate,
+            mainLanguages: [],
+        };
+    }
+    catch (error) {
+        logger_1.logger.warn('Git scan failed', { error, projectPath });
+        return {
+            totalCommits: 0,
+            contributors: 0,
+            lastCommitDate: '',
+            mainLanguages: [],
+        };
+    }
+}

package/dist/scanner/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Scanner Orchestrator
+ * Runs all scanner modules in sequence and assembles complete ArtifactInventory
+ */
+import { ArtifactInventory } from '../state/schema';
+/**
+ * Main scanner function that orchestrates all scanners
+ * Returns complete ArtifactInventory
+ */
+export declare function scan(projectPath: string): Promise<ArtifactInventory>;
+export { scanFiles } from './file-scanner';
+export { scanGit } from './git-scanner';
+export { scanCode } from './code-scanner';
+export { enrichArtifacts } from './artifact-scanner';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scanner/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAMpD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA8F1E;AAED,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/scanner/index.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Scanner Orchestrator
+ * Runs all scanner modules in sequence and assembles complete ArtifactInventory
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichArtifacts = exports.scanCode = exports.scanGit = exports.scanFiles = void 0;
+exports.scan = scan;
+const logger_1 = require("../utils/logger");
+const file_scanner_1 = require("./file-scanner");
+const git_scanner_1 = require("./git-scanner");
+const code_scanner_1 = require("./code-scanner");
+const artifact_scanner_1 = require("./artifact-scanner");
+/**
+ * Main scanner function that orchestrates all scanners
+ * Returns complete ArtifactInventory
+ */
+async function scan(projectPath) {
+    logger_1.logger.info('Starting comprehensive project scan', { projectPath });
+    try {
+        // Phase 1: File scanning
+        logger_1.logger.info('Phase 1/4: Scanning file structure...');
+        const fileResults = await (0, file_scanner_1.scanFiles)(projectPath);
+        // Phase 2: Git scanning
+        logger_1.logger.info('Phase 2/4: Analyzing git history...');
+        const gitStats = await (0, git_scanner_1.scanGit)(projectPath);
+        // Phase 3: Code scanning
+        logger_1.logger.info('Phase 3/4: Analyzing code structure...');
+        const codeStructure = await (0, code_scanner_1.scanCode)(projectPath);
+        // Phase 4: Artifact enrichment
+        logger_1.logger.info('Phase 4/4: Enriching artifacts with summaries...');
+        await (0, artifact_scanner_1.enrichArtifacts)(fileResults.documentation.files, fileResults.agentArtifacts.files, fileResults.configAsDocs.files);
+        // Assemble inventory
+        const totalArtifacts = fileResults.configAsDocs.count +
+            fileResults.agentArtifacts.count +
+            fileResults.sessionContext.count +
+            fileResults.documentation.count +
+            fileResults.packageConfigs.count +
+            fileResults.cicdConfigs.count +
+            fileResults.infrastructure.count +
+            fileResults.testFiles.count +
+            fileResults.apiSpecs.count +
+            fileResults.sourceCode.count;
+        // Map file scanner categories to inventory categories
+        const inventory = {
+            totalArtifacts,
+            categories: {
+                sourceCode: fileResults.sourceCode,
+                configuration: {
+                    files: [
+                        ...fileResults.packageConfigs.files,
+                        ...fileResults.cicdConfigs.files,
+                        ...fileResults.configAsDocs.files,
+                    ],
+                    count: fileResults.packageConfigs.count +
+                        fileResults.cicdConfigs.count +
+                        fileResults.configAsDocs.count,
+                },
+                documentation: fileResults.documentation,
+                tests: fileResults.testFiles,
+                architecture: {
+                    files: [
+                        ...fileResults.agentArtifacts.files,
+                        ...fileResults.sessionContext.files,
+                        ...fileResults.apiSpecs.files,
+                    ],
+                    count: fileResults.agentArtifacts.count +
+                        fileResults.sessionContext.count +
+                        fileResults.apiSpecs.count,
+                },
+                infrastructure: fileResults.infrastructure,
+            },
+            gitStats: {
+                ...gitStats,
+                mainLanguages: codeStructure.languages.map((l) => l.name),
+            },
+        };
+        logger_1.logger.info('Scan completed successfully', {
+            total: totalArtifacts,
+            categories: {
+                sourceCode: inventory.categories.sourceCode.count,
+                configuration: inventory.categories.configuration.count,
+                documentation: inventory.categories.documentation.count,
+                tests: inventory.categories.tests.count,
+                architecture: inventory.categories.architecture.count,
+                infrastructure: inventory.categories.infrastructure.count,
+            },
+            languages: inventory.gitStats.mainLanguages,
+            contributors: inventory.gitStats.contributors,
+            commits: inventory.gitStats.totalCommits,
+        });
+        return inventory;
+    }
+    catch (error) {
+        logger_1.logger.error('Scan failed', { error });
+        throw error;
+    }
+}
+var file_scanner_2 = require("./file-scanner");
+Object.defineProperty(exports, "scanFiles", { enumerable: true, get: function () { return file_scanner_2.scanFiles; } });
+var git_scanner_2 = require("./git-scanner");
+Object.defineProperty(exports, "scanGit", { enumerable: true, get: function () { return git_scanner_2.scanGit; } });
+var code_scanner_2 = require("./code-scanner");
+Object.defineProperty(exports, "scanCode", { enumerable: true, get: function () { return code_scanner_2.scanCode; } });
+var artifact_scanner_2 = require("./artifact-scanner");
+Object.defineProperty(exports, "enrichArtifacts", { enumerable: true, get: function () { return artifact_scanner_2.enrichArtifacts; } });

package/dist/state/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * State Management
+ * Handles reading and writing .vibe-doc/state.json
+ */
+import { VibedocState } from './schema';
+/**
+ * Read the vibe-doc state from disk
+ * Returns null if state file doesn't exist
+ */
+export declare function readState(projectPath: string): VibedocState | null;
+/**
+ * Write the vibe-doc state to disk
+ * Creates .vibe-doc directory if it doesn't exist
+ */
+export declare function writeState(projectPath: string, state: VibedocState): void;
+/**
+ * Initialize a fresh vibe-doc state with empty values
+ */
+export declare function initState(): VibedocState;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAKxC;;;GAGG;AACH,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAYlE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAWzE;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,YAAY,CAwDxC"}

package/dist/state/index.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * State Management
+ * Handles reading and writing .vibe-doc/state.json
+ */
+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.readState = readState;
+exports.writeState = writeState;
+exports.initState = initState;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const STATE_DIR = '.vibe-doc';
+const STATE_FILE = 'state.json';
+/**
+ * Read the vibe-doc state from disk
+ * Returns null if state file doesn't exist
+ */
+function readState(projectPath) {
+    try {
+        const statePath = path.join(projectPath, STATE_DIR, STATE_FILE);
+        if (!fs.existsSync(statePath)) {
+            return null;
+        }
+        const content = fs.readFileSync(statePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.error(`Failed to read state: ${error}`);
+        return null;
+    }
+}
+/**
+ * Write the vibe-doc state to disk
+ * Creates .vibe-doc directory if it doesn't exist
+ */
+function writeState(projectPath, state) {
+    try {
+        const stateDir = path.join(projectPath, STATE_DIR);
+        if (!fs.existsSync(stateDir)) {
+            fs.mkdirSync(stateDir, { recursive: true });
+        }
+        const statePath = path.join(stateDir, STATE_FILE);
+        fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to write state: ${error}`);
+    }
+}
+/**
+ * Initialize a fresh vibe-doc state with empty values
+ */
+function initState() {
+    return {
+        version: '1.0.0',
+        lastScan: new Date().toISOString(),
+        projectProfile: {
+            interviewAnswers: {
+                projectName: '',
+                projectDescription: '',
+                mainPurpose: '',
+                primaryUsers: '',
+                coreFeatures: [],
+                technologies: [],
+                deploymentModel: '',
+                architectureStyle: '',
+            },
+            providedContext: '',
+        },
+        artifactInventory: {
+            totalArtifacts: 0,
+            categories: {
+                sourceCode: { files: [], count: 0 },
+                configuration: { files: [], count: 0 },
+                documentation: { files: [], count: 0 },
+                tests: { files: [], count: 0 },
+                architecture: { files: [], count: 0 },
+                infrastructure: { files: [], count: 0 },
+            },
+            gitStats: {
+                totalCommits: 0,
+                contributors: 0,
+                lastCommitDate: '',
+                mainLanguages: [],
+            },
+        },
+        classification: {
+            primaryCategory: '',
+            secondaryCategory: '',
+            deploymentContext: [],
+            contextModifiers: [],
+            confidence: 0,
+            rationale: '',
+            userConfirmed: false,
+        },
+        gapReport: {
+            summary: {
+                totalArtifacts: 0,
+                docsCovered: 0,
+                docsPartial: 0,
+                docsMissing: 0,
+                coveragePercent: 0,
+            },
+            gaps: [],
+        },
+        generatedDocs: [],
+        history: [],
+    };
+}