@stackmemoryai/stackmemory 0.2.4 → 0.2.7

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

@@ -0,0 +1,709 @@
+/**
+ * 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