@stackmemoryai/stackmemory 0.5.59 → 0.5.62

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

@@ -1,697 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-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";
-class ProjectManager {
-  static instance;
-  db;
-  configPath;
-  organizations = /* @__PURE__ */ new Map();
-  projectCache = /* @__PURE__ */ 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 {
-      const cached = this.projectCache.get(path);
-      if (cached && this.isCacheValid(cached)) {
-        return cached;
-      }
-      const project = await this.analyzeProject(path);
-      if (project.gitRemote) {
-        project.organization = this.extractOrganization(project.gitRemote);
-        project.accountType = this.determineAccountType(
-          project.gitRemote,
-          project.organization
-        );
-        project.isPrivate = this.isPrivateRepo(project.gitRemote);
-      }
-      project.primaryLanguage = this.detectPrimaryLanguage(path);
-      project.framework = this.detectFramework(path);
-      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: void 0,
-      accountType: "personal",
-      isPrivate: false,
-      lastAccessed: /* @__PURE__ */ 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 {
-      info.remote = execSync("git config --get remote.origin.url", {
-        cwd: projectPath,
-        encoding: "utf-8",
-        timeout: 5e3
-        // 5 second timeout
-      }).trim();
-      info.branch = execSync("git branch --show-current", {
-        cwd: projectPath,
-        encoding: "utf-8",
-        timeout: 5e3
-      }).trim();
-      info.lastCommit = execSync("git log -1 --format=%H", {
-        cwd: projectPath,
-        encoding: "utf-8",
-        timeout: 5e3
-      }).trim();
-      const status = execSync("git status --porcelain", {
-        cwd: projectPath,
-        encoding: "utf-8",
-        timeout: 5e3
-      });
-      info.isDirty = status.length > 0;
-      const match = info.remote.match(/\/([^\/]+?)(\.git)?$/);
-      info.name = match ? match[1] : basename(projectPath);
-    } catch (error) {
-      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) {
-    const githubMatch = gitRemote.match(/github\.com[:/]([^/]+)\//);
-    if (githubMatch) return githubMatch[1];
-    const gitlabMatch = gitRemote.match(/gitlab\.com[:/]([^/]+)\//);
-    if (gitlabMatch) return gitlabMatch[1];
-    const bitbucketMatch = gitRemote.match(/bitbucket\.org[:/]([^/]+)\//);
-    if (bitbucketMatch) return bitbucketMatch[1];
-    const customMatch = gitRemote.match(/@([^:]+)[:/]([^/]+)\//);
-    if (customMatch) return customMatch[2];
-    return "unknown";
-  }
-  /**
-   * Determine account type based on patterns
-   */
-  determineAccountType(gitRemote, organization) {
-    for (const [, org] of this.organizations) {
-      if (org.githubOrgs.includes(organization || "")) {
-        return org.accountType;
-      }
-      for (const domain of org.domains) {
-        if (gitRemote.includes(domain)) {
-          return org.accountType;
-        }
-      }
-    }
-    if (organization) {
-      if (organization.includes("corp") || organization.includes("company") || organization.includes("team") || organization.includes("work")) {
-        return "work";
-      }
-      if (organization.includes("apache") || organization.includes("mozilla") || organization.includes("foundation") || gitRemote.includes("gitlab.freedesktop")) {
-        return "opensource";
-      }
-      const username = this.getCurrentGitUser();
-      if (username && organization.toLowerCase() === username.toLowerCase()) {
-        return "personal";
-      }
-    }
-    if (this.isPrivateRepo(gitRemote)) {
-      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) {
-    if (gitRemote.startsWith("git@")) {
-      return true;
-    }
-    if (gitRemote.includes("@")) {
-      return true;
-    }
-    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("*")) {
-        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 void 0;
-  }
-  /**
-   * 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 };
-        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 {
-      }
-    }
-    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 void 0;
-  }
-  /**
-   * 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 void 0;
-    }
-  }
-  /**
-   * Generate unique project ID
-   */
-  generateProjectId(identifier) {
-    const cleaned = identifier.replace(/\.git$/, "").replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
-    return cleaned.substring(cleaned.length - 50);
-  }
-  /**
-   * 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 : void 0
-      );
-    }
-  }
-  /**
-   * 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 : void 0
-      );
-    }
-  }
-  /**
-   * 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 : void 0
-        );
-      }
-    }
-  }
-  /**
-   * 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)) {
-          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 * 1e3;
-  }
-  /**
-   * 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 : void 0
-      );
-    }
-  }
-  /**
-   * 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 : void 0
-      );
-    }
-  }
-  /**
-   * 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 : void 0
-      );
-    }
-  }
-  /**
-   * 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);
-      const configFile = join(this.configPath, "organizations.json");
-      const config = {
-        organizations: Array.from(this.organizations.values())
-      };
-      writeFileSync(configFile, JSON.stringify(config, null, 2));
-      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 : void 0
-      );
-    }
-  }
-  /**
-   * 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 {
-        const gitDirs = execSync(
-          `find ${basePath} -type d -name .git -maxdepth 4 2>/dev/null`,
-          { encoding: "utf-8", timeout: 3e4 }
-          // 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 } : void 0
-        );
-      }
-    }
-    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) {
-      report.byAccountType[project.accountType] = (report.byAccountType[project.accountType] || 0) + 1;
-      if (project.organization) {
-        report.byOrganization[project.organization] = (report.byOrganization[project.organization] || 0) + 1;
-      }
-      if (project.primaryLanguage) {
-        report.byLanguage[project.primaryLanguage] = (report.byLanguage[project.primaryLanguage] || 0) + 1;
-      }
-      if (project.framework) {
-        report.byFramework[project.framework] = (report.byFramework[project.framework] || 0) + 1;
-      }
-    }
-    return JSON.stringify(report, null, 2);
-  }
-}
-export {
-  ProjectManager
-};
-//# sourceMappingURL=project-manager.js.map