nx-analyze 0.1.0

package/lib/db.js

@@ -0,0 +1,732 @@
+import { createRequire } from 'module';
+// Use CommonJS require for sqlite3 to ensure correct runtime shape under NodeNext/ESM
+const sqlite3 = createRequire(import.meta.url)('sqlite3');
+import * as path from 'path';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { createProjectGraphAsync, createProjectFileMapUsingProjectGraph, workspaceRoot, } from '@nx/devkit';
+import ts from 'typescript';
+export class ProjectDatabase {
+    db;
+    dbPath;
+    constructor(dbPath) {
+        this.dbPath = dbPath || path.join(process.cwd(), 'projects.db');
+        this.db = new sqlite3.Database(this.dbPath);
+        this.initializeDatabase();
+    }
+    initializeDatabase() {
+        const createProjectsTable = `
+      CREATE TABLE IF NOT EXISTS projects (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        description TEXT,
+        project_type TEXT,
+        source_root TEXT,
+        root TEXT,
+        tags TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+        const createFilesTable = `
+      CREATE TABLE IF NOT EXISTS project_files (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project_id INTEGER NOT NULL,
+        file_path TEXT NOT NULL,
+        file_type TEXT,
+        added_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (project_id) REFERENCES projects (id) ON DELETE CASCADE,
+        UNIQUE(project_id, file_path)
+      )
+    `;
+        const createCommitsTable = `
+      CREATE TABLE IF NOT EXISTS git_commits (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        hash TEXT UNIQUE NOT NULL,
+        author TEXT NOT NULL,
+        date TEXT NOT NULL,
+        message TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+        const createTouchedFilesTable = `
+      CREATE TABLE IF NOT EXISTS touched_files (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        commit_id INTEGER NOT NULL,
+        file_path TEXT NOT NULL,
+        change_type TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (commit_id) REFERENCES git_commits (id) ON DELETE CASCADE,
+        UNIQUE(commit_id, file_path)
+      )
+    `;
+        const createFileDepsTable = `
+      CREATE TABLE IF NOT EXISTS file_dependencies (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        file_path TEXT NOT NULL,
+        depends_on_project TEXT NOT NULL,
+        depends_on_file TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(file_path, depends_on_project, depends_on_file)
+      )
+    `;
+        this.db.serialize(() => {
+            this.db.run(createProjectsTable);
+            this.db.run(createFilesTable);
+            this.db.run(createCommitsTable);
+            this.db.run(createTouchedFilesTable);
+            this.db.run(createFileDepsTable);
+        });
+    }
+    query(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.all(sql, params, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(rows);
+                }
+            });
+        });
+    }
+    // Nx integration methods
+    async syncWithNxWorkspace(workspaceRoot) {
+        process.chdir(workspaceRoot || process.cwd());
+        try {
+            // Read Nx configuration and create project graph
+            const projectGraph = await createProjectGraphAsync({
+                exitOnError: false,
+            });
+            const fileMap = await createProjectFileMapUsingProjectGraph(projectGraph);
+            // Sync all Nx projects to database
+            for (const [projectName, files] of Object.entries(fileMap)) {
+                await this.syncNxProject(projectName, projectGraph.nodes[projectName], files);
+            }
+            return projectGraph;
+        }
+        catch (error) {
+            throw new Error(`Failed to sync with Nx workspace: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    async syncNxProject(projectName, projectNode, files) {
+        const data = projectNode.data;
+        // Create or update project in database
+        const existingProject = await this.getProject(projectName);
+        if (existingProject) {
+            // Update existing project
+            await this.updateProject(projectName, {
+                description: data.description,
+                project_type: data.projectType,
+                source_root: data.sourceRoot,
+                root: data.root,
+                tags: data.tags?.join(','),
+            });
+        }
+        else {
+            // Create new project
+            await this.createProjectFromNx(projectName, {
+                description: data.description,
+                project_type: data.projectType,
+                source_root: data.sourceRoot,
+                root: data.root,
+                tags: data.tags?.join(','),
+            });
+        }
+        // Add all files from the project
+        for (const file of files) {
+            await this.addFileToProject(projectName, file.file, file.deps?.map((d) => d[0]));
+        }
+    }
+    // Project methods
+    async createProject(name, description) {
+        return new Promise((resolve, reject) => {
+            const stmt = this.db.prepare('INSERT INTO projects (name, description) VALUES (?, ?)');
+            stmt.run([name, description], function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(this.lastID);
+                }
+            });
+            stmt.finalize();
+        });
+    }
+    async createProjectFromNx(name, nxData) {
+        return new Promise((resolve, reject) => {
+            const stmt = this.db.prepare(`
+        INSERT INTO projects (name, description, project_type, source_root, root, tags) 
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+            stmt.run([
+                name,
+                nxData.description,
+                nxData.project_type,
+                nxData.source_root,
+                nxData.root,
+                nxData.tags,
+            ], function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(this.lastID);
+                }
+            });
+            stmt.finalize();
+        });
+    }
+    async updateProject(name, updates) {
+        return new Promise((resolve, reject) => {
+            const stmt = this.db.prepare(`
+        UPDATE projects 
+        SET description = ?, project_type = ?, source_root = ?, root = ?, tags = ?
+        WHERE name = ?
+      `);
+            stmt.run([
+                updates.description,
+                updates.project_type,
+                updates.source_root,
+                updates.root,
+                updates.tags,
+                name,
+            ], function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve((this.changes ?? 0) > 0);
+                }
+            });
+            stmt.finalize();
+        });
+    }
+    async getProject(name) {
+        return new Promise((resolve, reject) => {
+            this.db.get('SELECT * FROM projects WHERE name = ?', [name], (err, row) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(row || null);
+                }
+            });
+        });
+    }
+    async getAllProjects() {
+        return this.query('SELECT * FROM projects ORDER BY name');
+    }
+    async deleteProject(name) {
+        return new Promise((resolve, reject) => {
+            this.db.run('DELETE FROM projects WHERE name = ?', [name], function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve((this.changes ?? 0) > 0);
+                }
+            });
+        });
+    }
+    async getProjectsByType(projectType) {
+        return this.query('SELECT * FROM projects WHERE project_type = ? ORDER BY name', [projectType]);
+    }
+    async getProjectsByTag(tag) {
+        return this.query('SELECT * FROM projects WHERE tags LIKE ? ORDER BY name', [`%${tag}%`]);
+    }
+    // File methods
+    async addFileToProject(projectName, filePath, fileDeps) {
+        const project = await this.getProject(projectName);
+        if (!project) {
+            throw new Error(`Project "${projectName}" not found`);
+        }
+        return new Promise((resolve, reject) => {
+            const stmt = this.db.prepare('INSERT OR REPLACE INTO project_files (project_id, file_path, file_type) VALUES (?, ?, ?)');
+            stmt.run([project.id, filePath, fileDeps], (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+            stmt.finalize();
+        });
+    }
+    async removeFileFromProject(projectName, filePath) {
+        const project = await this.getProject(projectName);
+        if (!project) {
+            return false;
+        }
+        return new Promise((resolve, reject) => {
+            this.db.run('DELETE FROM project_files WHERE project_id = ? AND file_path = ?', [project.id, filePath], function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve((this.changes ?? 0) > 0);
+                }
+            });
+        });
+    }
+    async getProjectFiles(projectName) {
+        const project = await this.getProject(projectName);
+        if (!project) {
+            return [];
+        }
+        return this.query('SELECT * FROM project_files WHERE project_id = ? ORDER BY file_path', [project.id]);
+    }
+    async getFileProjects(filePath) {
+        return this.query(`
+        SELECT p.* FROM projects p
+        JOIN project_files pf ON p.id = pf.project_id
+        WHERE pf.file_path = ?
+        ORDER BY p.name
+      `, [filePath]);
+    }
+    // Nx-specific query methods
+    async getProjectDependencies(projectName) {
+        try {
+            const projectGraph = await createProjectGraphAsync({
+                exitOnError: false,
+            });
+            const dependencies = projectGraph.dependencies[projectName] || [];
+            return dependencies.map((dep) => dep.target);
+        }
+        catch (error) {
+            console.warn(`Could not get dependencies for ${projectName}:`, error);
+            return [];
+        }
+    }
+    async getProjectDependents(projectName) {
+        try {
+            const projectGraph = await createProjectGraphAsync({
+                exitOnError: false,
+            });
+            const dependents = [];
+            for (const [project, deps] of Object.entries(projectGraph.dependencies)) {
+                if (deps.some((dep) => dep.target === projectName)) {
+                    dependents.push(project);
+                }
+            }
+            return dependents;
+        }
+        catch (error) {
+            console.warn(`Could not get dependents for ${projectName}:`, error);
+            return [];
+        }
+    }
+    async getAffectedProjects(changedFiles) {
+        try {
+            const affectedProjects = new Set();
+            // Find which projects contain the changed files
+            for (const filePath of changedFiles) {
+                const projects = await this.getFileProjects(filePath);
+                for (const project of projects) {
+                    affectedProjects.add(project.name);
+                    // Also add dependent projects
+                    const dependents = await this.getProjectDependents(project.name);
+                    dependents.forEach((dep) => affectedProjects.add(dep));
+                }
+            }
+            return Array.from(affectedProjects);
+        }
+        catch (error) {
+            console.warn('Could not determine affected projects:', error);
+            return [];
+        }
+    }
+    // File dependency methods (Nx file-map ingestion)
+    async clearFileDependencies() {
+        return new Promise((resolve, reject) => {
+            this.db.run('DELETE FROM file_dependencies', (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    // Accept an optional Program & TypeChecker to avoid rebuilding per-file (performance)
+    findDefinition(fileName, targetPackage, program, checker) {
+        let localProgram = program;
+        let localChecker = checker;
+        // If no program/checker provided, fall back to previous behavior (single-file program)
+        if (!localProgram || !localChecker) {
+            const configFilePath = ts.findConfigFile(fileName, ts.sys.fileExists) ||
+                path.join(workspaceRoot, 'tsconfig.json');
+            const configHost = {
+                ...ts.sys,
+                onUnRecoverableConfigFileDiagnostic: () => {
+                    /** intentionally empty */
+                },
+            };
+            const parsed = ts.getParsedCommandLineOfConfigFile(configFilePath, undefined, configHost);
+            localProgram = ts.createProgram([fileName], parsed?.options || {});
+            localChecker = localProgram.getTypeChecker();
+        }
+        const sourceFile = localProgram.getSourceFile(fileName);
+        const foundSymbols = [];
+        function visit(node) {
+            if (ts.isImportDeclaration(node)) {
+                // Get the module name (stripping quotes)
+                const moduleName = node.moduleSpecifier
+                    .getText(sourceFile)
+                    .replace(/['"]/g, '');
+                if (moduleName.includes(targetPackage)) {
+                    const importClause = node.importClause;
+                    if (importClause?.namedBindings &&
+                        ts.isNamedImports(importClause.namedBindings)) {
+                        // Handle Named Imports: import { useState, useEffect } from 'react'
+                        importClause.namedBindings.elements.forEach((namedImport) => {
+                            const symbol = localChecker.getSymbolAtLocation(namedImport.name);
+                            let defined_in_file = undefined;
+                            if (symbol) {
+                                // Follow the import chain to the original definition
+                                const aliasedSymbol = localChecker.getAliasedSymbol(symbol);
+                                const declaration = aliasedSymbol?.declarations?.[0] || symbol.declarations?.[0];
+                                if (declaration) {
+                                    defined_in_file = declaration
+                                        .getSourceFile()
+                                        .fileName.replace(workspaceRoot + '/', '');
+                                }
+                            }
+                            foundSymbols.push({
+                                symbol: namedImport.name.text,
+                                defined_in_project: targetPackage,
+                                defined_in_file,
+                            });
+                            // Keep logging for now; can be toggled later if needed
+                            // console.log(
+                            //   `Import: ${namedImport.name.text} in ${fileName} defined in: ${defined_in_file}`
+                            // );
+                        });
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        if (sourceFile)
+            visit(sourceFile);
+        return foundSymbols;
+    }
+    async addFileDependency(filePath, dependsOn) {
+        const foundSymbols = this.findDefinition(filePath, dependsOn);
+        return Promise.all(foundSymbols.map((foundSymbol) => new Promise((resolve, reject) => {
+            const stmt = this.db.prepare('INSERT OR IGNORE INTO file_dependencies (file_path, depends_on_project, depends_on_file) VALUES (?, ?, ?)');
+            stmt.run([filePath, dependsOn, foundSymbol.defined_in_file], (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+            stmt.finalize();
+        })));
+    }
+    async getFileDependencies(filePath) {
+        return this.query('SELECT depends_on_project FROM file_dependencies WHERE file_path = ? ORDER BY depends_on_project', [filePath]).then((rows) => rows.map((r) => r.depends_on_project));
+    }
+    async getFileDependents(dependsOn) {
+        return this.query('SELECT file_path FROM file_dependencies WHERE depends_on_project = ? ORDER BY file_path', [dependsOn]).then((rows) => rows.map((r) => r.file_path));
+    }
+    async syncFileDependenciesFromNx(workspaceRoot) {
+        const root = workspaceRoot ? path.resolve(workspaceRoot) : process.cwd();
+        // Determine Nx cache dir from nx.json if present, default to .nx
+        let cacheDir = '.nx';
+        try {
+            const nxJsonPath = path.join(root, 'nx.json');
+            if (fs.existsSync(nxJsonPath)) {
+                const nxConfig = JSON.parse(fs.readFileSync(nxJsonPath, 'utf8'));
+                const installation = nxConfig.installation;
+                if (installation &&
+                    typeof installation === 'object' &&
+                    typeof installation.cacheDirectory === 'string') {
+                    cacheDir = installation.cacheDirectory;
+                }
+            }
+        }
+        catch {
+            // ignore and use default
+        }
+        const fileMapPath = path.join(root, cacheDir, 'workspace-data', 'file-map.json');
+        if (!fs.existsSync(fileMapPath)) {
+            throw new Error(`Nx file map not found at ${fileMapPath}`);
+        }
+        const content = fs.readFileSync(fileMapPath, 'utf8');
+        const parsed = JSON.parse(content);
+        // Collect all file records to build a single TS program (faster than per-file)
+        const nonProjectFiles = parsed?.fileMap?.nonProjectFiles ?? [];
+        const projectFileMap = parsed?.fileMap?.projectFileMap ?? {};
+        const allEntries = [];
+        for (const entry of nonProjectFiles)
+            allEntries.push(entry);
+        for (const files of Object.values(projectFileMap)) {
+            for (const entry of files)
+                allEntries.push(entry);
+        }
+        // Build absolute file list for TS program
+        const allFileAbs = Array.from(new Set(allEntries.map((e) => path.resolve(root, e.file))));
+        // Try to create a single program; if it fails, fall back to per-file parsing
+        let program;
+        let checker;
+        try {
+            const configFilePath = ts.findConfigFile(root, ts.sys.fileExists) ||
+                path.join(root, 'tsconfig.json');
+            const configHost = {
+                ...ts.sys,
+                onUnRecoverableConfigFileDiagnostic: () => {
+                    /** intentionally empty */
+                },
+            };
+            const parsedConfig = ts.getParsedCommandLineOfConfigFile(configFilePath, undefined, configHost);
+            program = ts.createProgram(allFileAbs, parsedConfig?.options || {});
+            checker = program.getTypeChecker();
+        }
+        catch (e) {
+            // If program creation fails (e.g., missing files in test environment), we will
+            // gracefully fall back to the previous per-file approach below.
+            program = undefined;
+            checker = undefined;
+        }
+        let inserted = 0;
+        await this.clearFileDependencies();
+        // Gather dependency insertion records in memory first
+        const records = [];
+        const processEntry = (filePathRel, deps) => {
+            if (!deps || !Array.isArray(deps))
+                return;
+            for (const dep of deps) {
+                let depStr;
+                if (typeof dep === 'string')
+                    depStr = dep;
+                else if (Array.isArray(dep) &&
+                    dep.length > 0 &&
+                    typeof dep[0] === 'string')
+                    depStr = dep[0];
+                if (!depStr)
+                    continue;
+                if (depStr.startsWith('npm:') || depStr === 'dynamic')
+                    continue;
+                // Resolve file path to absolute when program provided
+                const absFile = path.resolve(root, filePathRel);
+                let found = [];
+                if (program && checker) {
+                    found = this.findDefinition(absFile, depStr, program, checker);
+                }
+                else {
+                    // Fallback to old behavior (slower)
+                    found = this.findDefinition(filePathRel, depStr);
+                }
+                for (const f of found) {
+                    records.push({
+                        filePath: filePathRel,
+                        dependsOn: depStr,
+                        defined_in_file: f.defined_in_file ?? null,
+                    });
+                    inserted++;
+                }
+            }
+        };
+        // Process all entries
+        for (const entry of allEntries) {
+            processEntry(entry.file, entry.deps);
+        }
+        // Batch insert all records in a single transaction for performance
+        if (records.length > 0) {
+            await new Promise((resolve, reject) => {
+                this.db.serialize(() => {
+                    this.db.run('BEGIN TRANSACTION');
+                    const stmt = this.db.prepare('INSERT OR IGNORE INTO file_dependencies (file_path, depends_on_project, depends_on_file) VALUES (?, ?, ?)');
+                    let pending = records.length;
+                    for (const r of records) {
+                        stmt.run([r.filePath, r.dependsOn, r.defined_in_file], (err) => {
+                            if (err) {
+                                // Ensure stmt finalized and propagate error
+                                stmt.finalize();
+                                reject(err);
+                                return;
+                            }
+                            pending--;
+                            if (pending === 0) {
+                                stmt.finalize((err) => {
+                                    if (err)
+                                        return reject(err);
+                                    this.db.run('COMMIT', (err) => {
+                                        if (err)
+                                            return reject(err);
+                                        resolve();
+                                    });
+                                });
+                            }
+                        });
+                    }
+                    // Handle case where records.length === 0 handled above
+                });
+            });
+        }
+        return inserted;
+    }
+    // Git commit tracking methods
+    async syncGitCommits(commitCount = 100) {
+        try {
+            // Get commit information using git log
+            const gitLogOutput = execSync(`git log --oneline --name-status -${commitCount} --pretty=format:"%H|%an|%ad|%s" --date=iso`, { encoding: 'utf8', cwd: process.cwd() });
+            const lines = gitLogOutput.split('\n').filter((line) => line.trim());
+            let currentCommit = null;
+            const touchedFiles = [];
+            for (const line of lines) {
+                if (line.includes('|')) {
+                    // This is a commit line
+                    if (currentCommit && touchedFiles.length > 0) {
+                        // Save the previous commit and its files
+                        await this.saveCommitWithFiles(currentCommit, touchedFiles);
+                        touchedFiles.length = 0; // Clear the array
+                    }
+                    const [hash, author, date, message] = line.split('|');
+                    currentCommit = {
+                        hash: hash.trim(),
+                        author: author.trim(),
+                        date: date.trim(),
+                        message: message.trim(),
+                    };
+                }
+                else if (currentCommit && line.match(/^[AMDRT]\s+/)) {
+                    // This is a file change line (A/M/D/R/T followed by filename)
+                    const changeType = line.charAt(0);
+                    const filePath = line.substring(2).trim();
+                    touchedFiles.push({ filePath, changeType });
+                }
+            }
+            // Don't forget the last commit
+            if (currentCommit && touchedFiles.length > 0) {
+                await this.saveCommitWithFiles(currentCommit, touchedFiles);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to sync git commits: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    async saveCommitWithFiles(commit, touchedFiles) {
+        // First, insert or get the commit
+        const commitId = await this.insertCommit(commit);
+        // Then insert all touched files for this commit
+        for (const file of touchedFiles) {
+            await this.insertTouchedFile(commitId, file.filePath, file.changeType);
+        }
+    }
+    async insertCommit(commit) {
+        return new Promise((resolve, reject) => {
+            // Use INSERT OR IGNORE to avoid duplicates
+            const dbRef = this.db;
+            const stmt = this.db.prepare(`
+        INSERT OR IGNORE INTO git_commits (hash, author, date, message) 
+        VALUES (?, ?, ?, ?)
+      `);
+            stmt.run([commit.hash, commit.author, commit.date, commit.message], function (err) {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                // If we inserted a new row, use the lastID
+                if ((this.lastID ?? 0) > 0) {
+                    resolve(this.lastID);
+                    return;
+                }
+                // Insert was ignored (duplicate hash). Query the existing row id.
+                dbRef.get('SELECT id FROM git_commits WHERE hash = ?', [commit.hash], (err2, row) => {
+                    if (err2) {
+                        reject(err2);
+                    }
+                    else if (row && typeof row.id === 'number') {
+                        resolve(row.id);
+                    }
+                    else {
+                        reject(new Error('Failed to insert or retrieve commit'));
+                    }
+                });
+            });
+            stmt.finalize();
+        });
+    }
+    async insertTouchedFile(commitId, filePath, changeType) {
+        return new Promise((resolve, reject) => {
+            const stmt = this.db.prepare(`
+        INSERT OR REPLACE INTO touched_files (commit_id, file_path, change_type) 
+        VALUES (?, ?, ?)
+      `);
+            stmt.run([commitId, filePath, changeType], (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+            stmt.finalize();
+        });
+    }
+    async getCommits(limit = 50) {
+        return this.query('SELECT * FROM git_commits ORDER BY date DESC LIMIT ?', [limit]);
+    }
+    async getTouchedFiles(commitHash) {
+        let query = `
+      SELECT tf.*, gc.hash, gc.author, gc.date, gc.message 
+      FROM touched_files tf
+      JOIN git_commits gc ON tf.commit_id = gc.id
+    `;
+        const params = [];
+        if (commitHash) {
+            query += ' WHERE gc.hash = ?';
+            params.push(commitHash);
+        }
+        query += ' ORDER BY gc.date DESC, tf.file_path';
+        return this.query(query, params);
+    }
+    async getFilesTouchedInLastCommits(commitCount = 100) {
+        const query = `
+      SELECT DISTINCT tf.file_path 
+      FROM touched_files tf
+      WHERE tf.commit_id IN (
+        SELECT id FROM git_commits 
+        ORDER BY date DESC 
+        LIMIT ?
+      )
+      ORDER BY tf.file_path
+    `;
+        return this.query(query, [commitCount]).then((rows) => rows.map((row) => row.file_path));
+    }
+    async getProjectsTouchedByCommits(commitCount = 100) {
+        try {
+            const touchedFiles = await this.getFilesTouchedInLastCommits(commitCount);
+            const touchedProjects = new Set();
+            for (const filePath of touchedFiles) {
+                const projects = await this.getFileProjects(filePath);
+                for (const project of projects) {
+                    touchedProjects.add(project.name);
+                }
+            }
+            return Array.from(touchedProjects);
+        }
+        catch (error) {
+            console.warn('Could not determine projects touched by commits:', error);
+            return [];
+        }
+    }
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.db.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+}
+// Export convenience functions
+export async function createDatabase(dbPath) {
+    return new ProjectDatabase(dbPath);
+}
+export function db() {
+    return 'db';
+}