@stackmemoryai/stackmemory 0.3.1 → 0.3.5

package/dist/src/core/projects/project-manager.js

@@ -1,709 +0,0 @@
-/**
- * Automatic Project Management for StackMemory
- * Auto-detects and organizes projects based on Git origins
- */
-import { execSync } from 'child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, basename, dirname } from 'path';
-import { homedir } from 'os';
-import Database from 'better-sqlite3';
-import { logger } from '../monitoring/logger.js';
-import { DatabaseError, ProjectError, ErrorCode, createErrorHandler, } from '../errors/index.js';
-import { retry } from '../errors/recovery.js';
-export class ProjectManager {
-    static instance;
-    db;
-    configPath;
-    organizations = new Map();
-    projectCache = new Map();
-    currentProject;
-    constructor() {
-        this.configPath = join(homedir(), '.stackmemory');
-        this.ensureDirectoryStructure();
-        this.initializeDatabase();
-        this.loadOrganizations();
-        this.autoDiscoverOrganizations();
-    }
-    static getInstance() {
-        if (!ProjectManager.instance) {
-            ProjectManager.instance = new ProjectManager();
-        }
-        return ProjectManager.instance;
-    }
-    /**
-     * Auto-detect project from current directory
-     */
-    async detectProject(projectPath) {
-        const path = projectPath || process.cwd();
-        const errorHandler = createErrorHandler({
-            operation: 'detectProject',
-            projectPath: path,
-        });
-        try {
-            // Check cache first
-            const cached = this.projectCache.get(path);
-            if (cached && this.isCacheValid(cached)) {
-                return cached;
-            }
-            const project = await this.analyzeProject(path);
-            // Auto-categorize based on git origin
-            if (project.gitRemote) {
-                project.organization = this.extractOrganization(project.gitRemote);
-                project.accountType = this.determineAccountType(project.gitRemote, project.organization);
-                project.isPrivate = this.isPrivateRepo(project.gitRemote);
-            }
-            // Detect framework and language
-            project.primaryLanguage = this.detectPrimaryLanguage(path);
-            project.framework = this.detectFramework(path);
-            // Store in database with retry logic
-            await retry(() => Promise.resolve(this.saveProject(project)), {
-                maxAttempts: 3,
-                initialDelay: 100,
-                onRetry: (attempt, error) => {
-                    logger.warn(`Retrying project save (attempt ${attempt})`, {
-                        projectId: project.id,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                },
-            });
-            this.projectCache.set(path, project);
-            this.currentProject = project;
-            logger.info('Project auto-detected', {
-                id: project.id,
-                org: project.organization,
-                type: project.accountType,
-            });
-            return project;
-        }
-        catch (error) {
-            const wrappedError = errorHandler(error, {
-                projectPath: path,
-                operation: 'detectProject',
-            });
-            throw new ProjectError(`Failed to detect project at path: ${path}`, ErrorCode.PROJECT_INVALID_PATH, {
-                projectPath: path,
-                operation: 'detectProject',
-            });
-        }
-    }
-    /**
-     * Analyze project directory
-     */
-    async analyzeProject(projectPath) {
-        const gitInfo = this.getGitInfo(projectPath);
-        const projectName = gitInfo.name || basename(projectPath);
-        return {
-            id: this.generateProjectId(gitInfo.remote || projectPath),
-            name: projectName,
-            path: projectPath,
-            gitRemote: gitInfo.remote,
-            organization: undefined,
-            accountType: 'personal',
-            isPrivate: false,
-            lastAccessed: new Date(),
-            metadata: {
-                branch: gitInfo.branch,
-                lastCommit: gitInfo.lastCommit,
-                isDirty: gitInfo.isDirty,
-            },
-        };
-    }
-    /**
-     * Extract Git information
-     */
-    getGitInfo(projectPath) {
-        const info = {};
-        const errorHandler = createErrorHandler({
-            operation: 'getGitInfo',
-            projectPath,
-        });
-        try {
-            // Get remote origin
-            info.remote = execSync('git config --get remote.origin.url', {
-                cwd: projectPath,
-                encoding: 'utf-8',
-                timeout: 5000, // 5 second timeout
-            }).trim();
-            // Get current branch
-            info.branch = execSync('git branch --show-current', {
-                cwd: projectPath,
-                encoding: 'utf-8',
-                timeout: 5000,
-            }).trim();
-            // Get last commit
-            info.lastCommit = execSync('git log -1 --format=%H', {
-                cwd: projectPath,
-                encoding: 'utf-8',
-                timeout: 5000,
-            }).trim();
-            // Check if working tree is dirty
-            const status = execSync('git status --porcelain', {
-                cwd: projectPath,
-                encoding: 'utf-8',
-                timeout: 5000,
-            });
-            info.isDirty = status.length > 0;
-            // Extract project name from remote
-            const match = info.remote.match(/\/([^\/]+?)(\.git)?$/);
-            info.name = match ? match[1] : basename(projectPath);
-        }
-        catch (error) {
-            // Not a git repository or git not available
-            logger.debug('Git info extraction failed, using directory name', {
-                projectPath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            info.name = basename(projectPath);
-        }
-        return info;
-    }
-    /**
-     * Extract organization from Git remote
-     */
-    extractOrganization(gitRemote) {
-        // GitHub: git@github.com:org/repo.git or https://github.com/org/repo
-        const githubMatch = gitRemote.match(/github\.com[:/]([^/]+)\//);
-        if (githubMatch)
-            return githubMatch[1];
-        // GitLab: git@gitlab.com:org/repo.git
-        const gitlabMatch = gitRemote.match(/gitlab\.com[:/]([^/]+)\//);
-        if (gitlabMatch)
-            return gitlabMatch[1];
-        // Bitbucket: git@bitbucket.org:org/repo.git
-        const bitbucketMatch = gitRemote.match(/bitbucket\.org[:/]([^/]+)\//);
-        if (bitbucketMatch)
-            return bitbucketMatch[1];
-        // Custom domain: git@git.company.com:team/repo.git
-        const customMatch = gitRemote.match(/@([^:]+)[:/]([^/]+)\//);
-        if (customMatch)
-            return customMatch[2];
-        return 'unknown';
-    }
-    /**
-     * Determine account type based on patterns
-     */
-    determineAccountType(gitRemote, organization) {
-        // Check against known organizations
-        for (const [, org] of this.organizations) {
-            if (org.githubOrgs.includes(organization || '')) {
-                return org.accountType;
-            }
-            // Check if remote matches any known domain
-            for (const domain of org.domains) {
-                if (gitRemote.includes(domain)) {
-                    return org.accountType;
-                }
-            }
-        }
-        // Auto-detection heuristics
-        if (organization) {
-            // Common work patterns
-            if (organization.includes('corp') ||
-                organization.includes('company') ||
-                organization.includes('team') ||
-                organization.includes('work')) {
-                return 'work';
-            }
-            // Common opensource patterns
-            if (organization.includes('apache') ||
-                organization.includes('mozilla') ||
-                organization.includes('foundation') ||
-                gitRemote.includes('gitlab.freedesktop')) {
-                return 'opensource';
-            }
-            // Check if it's the user's own org
-            const username = this.getCurrentGitUser();
-            if (username && organization.toLowerCase() === username.toLowerCase()) {
-                return 'personal';
-            }
-        }
-        // Check if it's a private repo (likely work or personal)
-        if (this.isPrivateRepo(gitRemote)) {
-            // Use additional heuristics
-            const currentPath = process.cwd();
-            if (currentPath.includes('/work/') ||
-                currentPath.includes('/Work/') ||
-                currentPath.includes('/company/') ||
-                currentPath.includes('/job/')) {
-                return 'work';
-            }
-        }
-        return 'personal';
-    }
-    /**
-     * Check if repository is private
-     */
-    isPrivateRepo(gitRemote) {
-        // SSH URLs are typically private
-        if (gitRemote.startsWith('git@')) {
-            return true;
-        }
-        // HTTPS with credentials
-        if (gitRemote.includes('@')) {
-            return true;
-        }
-        // Try to check GitHub API (requires authentication for private repos)
-        // This is a simplified check
-        return false;
-    }
-    /**
-     * Detect primary programming language
-     */
-    detectPrimaryLanguage(projectPath) {
-        const checks = [
-            { file: 'package.json', language: 'JavaScript/TypeScript' },
-            { file: 'Cargo.toml', language: 'Rust' },
-            { file: 'go.mod', language: 'Go' },
-            { file: 'pom.xml', language: 'Java' },
-            { file: 'requirements.txt', language: 'Python' },
-            { file: 'Gemfile', language: 'Ruby' },
-            { file: 'composer.json', language: 'PHP' },
-            { file: '*.csproj', language: 'C#' },
-            { file: 'Podfile', language: 'Swift/Objective-C' },
-        ];
-        for (const check of checks) {
-            if (check.file.includes('*')) {
-                // Glob pattern
-                try {
-                    const files = execSync(`find ${projectPath} -maxdepth 2 -name "${check.file}" 2>/dev/null`, {
-                        encoding: 'utf-8',
-                    });
-                    if (files.trim())
-                        return check.language;
-                }
-                catch { }
-            }
-            else if (existsSync(join(projectPath, check.file))) {
-                return check.language;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Detect framework
-     */
-    detectFramework(projectPath) {
-        const packageJsonPath = join(projectPath, 'package.json');
-        if (existsSync(packageJsonPath)) {
-            try {
-                const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-                // Check for common frameworks
-                if (deps['next'])
-                    return 'Next.js';
-                if (deps['react'])
-                    return 'React';
-                if (deps['vue'])
-                    return 'Vue';
-                if (deps['@angular/core'])
-                    return 'Angular';
-                if (deps['express'])
-                    return 'Express';
-                if (deps['fastify'])
-                    return 'Fastify';
-                if (deps['@nestjs/core'])
-                    return 'NestJS';
-            }
-            catch { }
-        }
-        // Check for other framework indicators
-        if (existsSync(join(projectPath, 'Cargo.toml'))) {
-            const cargo = readFileSync(join(projectPath, 'Cargo.toml'), 'utf-8');
-            if (cargo.includes('actix-web'))
-                return 'Actix';
-            if (cargo.includes('rocket'))
-                return 'Rocket';
-        }
-        return undefined;
-    }
-    /**
-     * Get current Git user
-     */
-    getCurrentGitUser() {
-        try {
-            const email = execSync('git config --global user.email', {
-                encoding: 'utf-8',
-            }).trim();
-            const username = email.split('@')[0];
-            return username;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /**
-     * Generate unique project ID
-     */
-    generateProjectId(identifier) {
-        // Create a stable ID from the git remote or path
-        const cleaned = identifier
-            .replace(/\.git$/, '')
-            .replace(/[^a-zA-Z0-9-]/g, '-')
-            .toLowerCase();
-        return cleaned.substring(cleaned.length - 50); // Last 50 chars
-    }
-    /**
-     * Initialize database
-     */
-    initializeDatabase() {
-        const dbPath = join(this.configPath, 'projects.db');
-        const errorHandler = createErrorHandler({
-            operation: 'initializeDatabase',
-            dbPath,
-        });
-        try {
-            this.db = new Database(dbPath);
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS projects (
-          id TEXT PRIMARY KEY,
-          name TEXT NOT NULL,
-          path TEXT NOT NULL UNIQUE,
-          git_remote TEXT,
-          organization TEXT,
-          account_type TEXT,
-          is_private BOOLEAN,
-          primary_language TEXT,
-          framework TEXT,
-          last_accessed DATETIME,
-          metadata JSON,
-          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-        );
-
-        CREATE TABLE IF NOT EXISTS organizations (
-          name TEXT PRIMARY KEY,
-          type TEXT,
-          account_type TEXT,
-          config JSON,
-          created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-        );
-
-        CREATE TABLE IF NOT EXISTS project_contexts (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          project_id TEXT NOT NULL,
-          context_type TEXT,
-          content TEXT,
-          metadata JSON,
-          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-          FOREIGN KEY (project_id) REFERENCES projects(id)
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_projects_org ON projects(organization);
-        CREATE INDEX IF NOT EXISTS idx_projects_type ON projects(account_type);
-        CREATE INDEX IF NOT EXISTS idx_contexts_project ON project_contexts(project_id);
-      `);
-        }
-        catch (error) {
-            const dbError = errorHandler(error, {
-                dbPath,
-                operation: 'initializeDatabase',
-            });
-            throw new DatabaseError('Failed to initialize projects database', ErrorCode.DB_MIGRATION_FAILED, {
-                dbPath,
-                configPath: this.configPath,
-                operation: 'initializeDatabase',
-            }, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Save project to database
-     */
-    saveProject(project) {
-        try {
-            const stmt = this.db.prepare(`
-        INSERT OR REPLACE INTO projects 
-        (id, name, path, git_remote, organization, account_type, is_private, 
-         primary_language, framework, last_accessed, metadata, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-      `);
-            stmt.run(project.id, project.name, project.path, project.gitRemote, project.organization, project.accountType, project.isPrivate ? 1 : 0, project.primaryLanguage, project.framework, project.lastAccessed.toISOString(), JSON.stringify(project.metadata));
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to save project: ${project.name}`, ErrorCode.DB_QUERY_FAILED, {
-                projectId: project.id,
-                projectName: project.name,
-                projectPath: project.path,
-                operation: 'saveProject',
-            }, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Load organizations configuration
-     */
-    loadOrganizations() {
-        const configFile = join(this.configPath, 'organizations.json');
-        if (existsSync(configFile)) {
-            try {
-                const config = JSON.parse(readFileSync(configFile, 'utf-8'));
-                for (const org of config.organizations || []) {
-                    this.organizations.set(org.name, org);
-                }
-            }
-            catch (error) {
-                logger.error('Failed to load organizations config', error instanceof Error ? error : undefined);
-            }
-        }
-    }
-    /**
-     * Auto-discover organizations from existing projects
-     */
-    autoDiscoverOrganizations() {
-        const errorHandler = createErrorHandler({
-            operation: 'autoDiscoverOrganizations',
-        });
-        try {
-            const stmt = this.db.prepare(`
-        SELECT DISTINCT organization, account_type, COUNT(*) as project_count
-        FROM projects
-        WHERE organization IS NOT NULL
-        GROUP BY organization, account_type
-      `);
-            const orgs = stmt.all();
-            for (const org of orgs) {
-                if (!this.organizations.has(org.organization)) {
-                    // Auto-create organization config
-                    this.organizations.set(org.organization, {
-                        name: org.organization,
-                        type: org.account_type === 'work' ? 'company' : 'personal',
-                        domains: [],
-                        githubOrgs: [org.organization],
-                        accountType: org.account_type,
-                        autoPatterns: [],
-                    });
-                }
-            }
-        }
-        catch (error) {
-            const wrappedError = errorHandler(error, {
-                operation: 'autoDiscoverOrganizations',
-            });
-            logger.error('Failed to auto-discover organizations', error instanceof Error ? error : new Error(String(error)), {
-                operation: 'autoDiscoverOrganizations',
-            });
-        }
-    }
-    /**
-     * Ensure directory structure exists
-     */
-    ensureDirectoryStructure() {
-        const dirs = [
-            this.configPath,
-            join(this.configPath, 'accounts'),
-            join(this.configPath, 'accounts', 'personal'),
-            join(this.configPath, 'accounts', 'work'),
-            join(this.configPath, 'accounts', 'opensource'),
-            join(this.configPath, 'accounts', 'client'),
-            join(this.configPath, 'contexts'),
-            join(this.configPath, 'patterns'),
-        ];
-        for (const dir of dirs) {
-            if (!existsSync(dir)) {
-                mkdirSync(dir, { recursive: true });
-            }
-        }
-    }
-    /**
-     * Check if cache is still valid
-     */
-    isCacheValid(project) {
-        const cacheAge = Date.now() - project.lastAccessed.getTime();
-        return cacheAge < 5 * 60 * 1000; // 5 minutes
-    }
-    /**
-     * Get all projects
-     */
-    getAllProjects() {
-        try {
-            const stmt = this.db.prepare(`
-        SELECT * FROM projects
-        ORDER BY last_accessed DESC
-      `);
-            const projects = stmt.all();
-            return projects.map((p) => ({
-                ...p,
-                isPrivate: p.is_private === 1,
-                lastAccessed: new Date(p.last_accessed),
-                metadata: JSON.parse(p.metadata || '{}'),
-            }));
-        }
-        catch (error) {
-            throw new DatabaseError('Failed to get all projects', ErrorCode.DB_QUERY_FAILED, {
-                operation: 'getAllProjects',
-            }, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Get projects by organization
-     */
-    getProjectsByOrganization(organization) {
-        try {
-            const stmt = this.db.prepare(`
-        SELECT * FROM projects
-        WHERE organization = ?
-        ORDER BY last_accessed DESC
-      `);
-            const projects = stmt.all(organization);
-            return projects.map((p) => ({
-                ...p,
-                isPrivate: p.is_private === 1,
-                lastAccessed: new Date(p.last_accessed),
-                metadata: JSON.parse(p.metadata || '{}'),
-            }));
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to get projects by organization: ${organization}`, ErrorCode.DB_QUERY_FAILED, {
-                organization,
-                operation: 'getProjectsByOrganization',
-            }, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Get projects by account type
-     */
-    getProjectsByAccountType(accountType) {
-        try {
-            const stmt = this.db.prepare(`
-        SELECT * FROM projects
-        WHERE account_type = ?
-        ORDER BY last_accessed DESC
-      `);
-            const projects = stmt.all(accountType);
-            return projects.map((p) => ({
-                ...p,
-                isPrivate: p.is_private === 1,
-                lastAccessed: new Date(p.last_accessed),
-                metadata: JSON.parse(p.metadata || '{}'),
-            }));
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to get projects by account type: ${accountType}`, ErrorCode.DB_QUERY_FAILED, {
-                accountType,
-                operation: 'getProjectsByAccountType',
-            }, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Get current project
-     */
-    getCurrentProject() {
-        if (!this.currentProject) {
-            this.detectProject();
-        }
-        return this.currentProject;
-    }
-    /**
-     * Save organization config
-     */
-    saveOrganization(org) {
-        const errorHandler = createErrorHandler({
-            operation: 'saveOrganization',
-            orgName: org.name,
-        });
-        try {
-            this.organizations.set(org.name, org);
-            // Save to file
-            const configFile = join(this.configPath, 'organizations.json');
-            const config = {
-                organizations: Array.from(this.organizations.values()),
-            };
-            writeFileSync(configFile, JSON.stringify(config, null, 2));
-            // Save to database
-            const stmt = this.db.prepare(`
-        INSERT OR REPLACE INTO organizations (name, type, account_type, config)
-        VALUES (?, ?, ?, ?)
-      `);
-            stmt.run(org.name, org.type, org.accountType, JSON.stringify(org));
-        }
-        catch (error) {
-            const wrappedError = errorHandler(error, {
-                orgName: org.name,
-                operation: 'saveOrganization',
-            });
-            throw new DatabaseError(`Failed to save organization: ${org.name}`, ErrorCode.DB_QUERY_FAILED, {
-                orgName: org.name,
-                operation: 'saveOrganization',
-            }, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Auto-categorize all Git repositories in home directory
-     */
-    async scanAndCategorizeAllProjects(basePaths) {
-        const paths = basePaths || [
-            join(homedir(), 'Dev'),
-            join(homedir(), 'dev'),
-            join(homedir(), 'Projects'),
-            join(homedir(), 'projects'),
-            join(homedir(), 'Work'),
-            join(homedir(), 'work'),
-            join(homedir(), 'Documents/GitHub'),
-            join(homedir(), 'code'),
-        ];
-        logger.info('Scanning for Git repositories...');
-        for (const basePath of paths) {
-            if (!existsSync(basePath))
-                continue;
-            try {
-                // Find all .git directories with timeout
-                const gitDirs = execSync(`find ${basePath} -type d -name .git -maxdepth 4 2>/dev/null`, { encoding: 'utf-8', timeout: 30000 } // 30 second timeout
-                )
-                    .trim()
-                    .split('\n')
-                    .filter(Boolean);
-                for (const gitDir of gitDirs) {
-                    const projectPath = dirname(gitDir);
-                    try {
-                        await this.detectProject(projectPath);
-                        logger.info(`Discovered project: ${projectPath}`);
-                    }
-                    catch (error) {
-                        logger.warn(`Failed to analyze project: ${projectPath}`, {
-                            projectPath,
-                            error: error instanceof Error ? error.message : String(error),
-                            operation: 'scanAndCategorizeAllProjects',
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                logger.warn(`Failed to scan ${basePath}`, error instanceof Error ? { error } : undefined);
-            }
-        }
-        logger.info(`Scan complete. Found ${this.projectCache.size} projects`);
-    }
-    /**
-     * Generate summary report
-     */
-    generateReport() {
-        const allProjects = this.getAllProjects();
-        const report = {
-            total: allProjects.length,
-            byAccountType: {},
-            byOrganization: {},
-            byLanguage: {},
-            byFramework: {},
-        };
-        for (const project of allProjects) {
-            // Count by account type
-            report.byAccountType[project.accountType] =
-                (report.byAccountType[project.accountType] || 0) + 1;
-            // Count by organization
-            if (project.organization) {
-                report.byOrganization[project.organization] =
-                    (report.byOrganization[project.organization] || 0) + 1;
-            }
-            // Count by language
-            if (project.primaryLanguage) {
-                report.byLanguage[project.primaryLanguage] =
-                    (report.byLanguage[project.primaryLanguage] || 0) + 1;
-            }
-            // Count by framework
-            if (project.framework) {
-                report.byFramework[project.framework] =
-                    (report.byFramework[project.framework] || 0) + 1;
-            }
-        }
-        return JSON.stringify(report, null, 2);
-    }
-}
-//# sourceMappingURL=project-manager.js.map