openspec-stat 1.2.0 → 1.3.1

package/dist/cjs/multi/config-wizard.js

@@ -0,0 +1,331 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/multi/config-wizard.ts
+var config_wizard_exports = {};
+__export(config_wizard_exports, {
+  MULTI_REPO_TEMPLATE: () => MULTI_REPO_TEMPLATE,
+  SINGLE_REPO_TEMPLATE: () => SINGLE_REPO_TEMPLATE,
+  runConfigWizard: () => runConfigWizard
+});
+module.exports = __toCommonJS(config_wizard_exports);
+var import_prompts = require("@inquirer/prompts");
+var import_chalk = __toESM(require("chalk"));
+var import_fs = require("fs");
+var import_i18n = require("../i18n/index.js");
+async function runConfigWizard(isMultiRepo = false) {
+  console.log(import_chalk.default.blue.bold(isMultiRepo ? (0, import_i18n.t)("init.welcomeMulti") : (0, import_i18n.t)("init.welcome")));
+  const configName = await (0, import_prompts.input)({
+    message: (0, import_i18n.t)("init.configName"),
+    default: isMultiRepo ? ".openspec-stats.multi.json" : ".openspec-stats.json"
+  });
+  if (!isMultiRepo) {
+    const singleRepoConfig = await createSingleRepoConfig();
+    saveConfig(configName, singleRepoConfig);
+    return;
+  }
+  const repositories = [];
+  let addMore = true;
+  while (addMore) {
+    console.log(import_chalk.default.cyan((0, import_i18n.t)("init.addRepository", { number: String(repositories.length + 1) })));
+    const repo = await addRepository();
+    repositories.push(repo);
+    addMore = await (0, import_prompts.confirm)({
+      message: (0, import_i18n.t)("init.addMore"),
+      default: false
+    });
+  }
+  console.log(import_chalk.default.cyan((0, import_i18n.t)("init.timeConfig")));
+  const timeConfig = await configureTimeRange();
+  console.log(import_chalk.default.cyan((0, import_i18n.t)("init.advanced")));
+  const advancedConfig = await configureAdvanced();
+  const config = {
+    mode: "multi-repo",
+    repositories,
+    ...timeConfig,
+    ...advancedConfig
+  };
+  console.log(import_chalk.default.green((0, import_i18n.t)("init.preview")));
+  console.log(JSON.stringify(config, null, 2));
+  const confirmed = await (0, import_prompts.confirm)({
+    message: (0, import_i18n.t)("init.save"),
+    default: true
+  });
+  if (confirmed) {
+    saveConfig(configName, config);
+    console.log(import_chalk.default.green((0, import_i18n.t)("init.saved", { path: configName })));
+    console.log(import_chalk.default.blue((0, import_i18n.t)("init.runCommand", { path: configName })));
+  }
+}
+async function createSingleRepoConfig() {
+  console.log(import_chalk.default.cyan((0, import_i18n.t)("init.timeConfig")));
+  const timeConfig = await configureTimeRange();
+  const branches = await (0, import_prompts.input)({
+    message: (0, import_i18n.t)("init.branches"),
+    default: "origin/master"
+  });
+  const advancedConfig = await configureAdvanced();
+  return {
+    defaultBranches: branches.split(",").map((b) => b.trim()).filter(Boolean),
+    ...timeConfig,
+    ...advancedConfig
+  };
+}
+async function addRepository() {
+  const type = await (0, import_prompts.select)({
+    message: (0, import_i18n.t)("init.repoType"),
+    choices: [
+      {
+        name: (0, import_i18n.t)("init.repoType.local"),
+        value: "local"
+      },
+      {
+        name: (0, import_i18n.t)("init.repoType.remote"),
+        value: "remote"
+      }
+    ]
+  });
+  const name = await (0, import_prompts.input)({
+    message: (0, import_i18n.t)("init.repoName"),
+    validate: (value) => value.length > 0 || "Name is required"
+  });
+  const repo = {
+    name,
+    type,
+    branches: []
+  };
+  if (type === "local") {
+    repo.path = await (0, import_prompts.input)({
+      message: (0, import_i18n.t)("init.repoPath"),
+      default: ".",
+      validate: (value) => value.length > 0 || "Path is required"
+    });
+  } else {
+    repo.url = await (0, import_prompts.input)({
+      message: (0, import_i18n.t)("init.repoUrl"),
+      validate: (value) => {
+        if (!value.length)
+          return "URL is required";
+        if (!value.match(/^(git@|https:\/\/)/)) {
+          return (0, import_i18n.t)("init.repoUrlInvalid");
+        }
+        return true;
+      }
+    });
+    const useFullClone = await (0, import_prompts.confirm)({
+      message: (0, import_i18n.t)("init.useFullClone"),
+      default: true
+    });
+    if (!useFullClone) {
+      const depth = await (0, import_prompts.input)({
+        message: (0, import_i18n.t)("init.cloneDepth"),
+        default: "100",
+        validate: (value) => !isNaN(Number(value)) || "Must be a number"
+      });
+      repo.cloneOptions = { depth: Number(depth) };
+    } else {
+      repo.cloneOptions = { depth: null };
+    }
+  }
+  const branchInput = await (0, import_prompts.input)({
+    message: (0, import_i18n.t)("init.branches"),
+    default: "origin/master"
+  });
+  repo.branches = branchInput.split(",").map((b) => b.trim()).filter(Boolean);
+  return repo;
+}
+async function configureTimeRange() {
+  const useDefault = await (0, import_prompts.confirm)({
+    message: (0, import_i18n.t)("init.useDefaultTime"),
+    default: true
+  });
+  if (useDefault) {
+    return {
+      defaultSinceHours: -30,
+      defaultUntilHours: 20
+    };
+  }
+  const sinceHours = await (0, import_prompts.input)({
+    message: (0, import_i18n.t)("init.sinceHours"),
+    default: "-30",
+    validate: (value) => !isNaN(Number(value)) || "Must be a number"
+  });
+  const untilHours = await (0, import_prompts.input)({
+    message: (0, import_i18n.t)("init.untilHours"),
+    default: "20",
+    validate: (value) => {
+      const num = Number(value);
+      return !isNaN(num) && num >= 0 && num <= 23 || "Must be 0-23";
+    }
+  });
+  return {
+    defaultSinceHours: Number(sinceHours),
+    defaultUntilHours: Number(untilHours)
+  };
+}
+async function configureAdvanced() {
+  const configureAdvanced2 = await (0, import_prompts.confirm)({
+    message: (0, import_i18n.t)("init.configureAdvanced"),
+    default: false
+  });
+  if (!configureAdvanced2) {
+    return getDefaultAdvancedConfig();
+  }
+  const config = {};
+  config.openspecDir = await (0, import_prompts.input)({
+    message: (0, import_i18n.t)("init.openspecDir"),
+    default: "openspec/"
+  });
+  const maxConcurrent = await (0, import_prompts.input)({
+    message: (0, import_i18n.t)("init.maxConcurrent"),
+    default: "3",
+    validate: (value) => {
+      const num = Number(value);
+      return !isNaN(num) && num > 0 || "Must be positive number";
+    }
+  });
+  config.parallelism = {
+    maxConcurrent: Number(maxConcurrent),
+    timeout: 6e5
+  };
+  config.remoteCache = {
+    dir: "/tmp/openspec-stat-cache",
+    autoCleanup: true,
+    cleanupOnComplete: true,
+    cleanupOnError: true
+  };
+  config.excludeExtensions = [".md", ".txt", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".webp"];
+  config.activeUserWeeks = 2;
+  const addAuthorMapping = await (0, import_prompts.confirm)({
+    message: (0, import_i18n.t)("init.authorMapping"),
+    default: false
+  });
+  if (addAuthorMapping) {
+    config.authorMapping = await configureAuthorMapping();
+  } else {
+    config.authorMapping = {};
+  }
+  return config;
+}
+async function configureAuthorMapping() {
+  console.log(import_chalk.default.gray((0, import_i18n.t)("init.authorMappingInfo")));
+  const mapping = {};
+  let addMore = true;
+  while (addMore) {
+    const gitIdentity = await (0, import_prompts.input)({
+      message: (0, import_i18n.t)("init.gitIdentity")
+    });
+    if (!gitIdentity)
+      break;
+    const unifiedName = await (0, import_prompts.input)({
+      message: (0, import_i18n.t)("init.unifiedName", { identity: gitIdentity })
+    });
+    mapping[gitIdentity] = unifiedName;
+    addMore = await (0, import_prompts.confirm)({
+      message: (0, import_i18n.t)("init.addMoreMapping"),
+      default: false
+    });
+  }
+  return mapping;
+}
+function getDefaultAdvancedConfig() {
+  return {
+    openspecDir: "openspec/",
+    excludeExtensions: [".md", ".txt", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".webp"],
+    activeUserWeeks: 2,
+    authorMapping: {},
+    parallelism: {
+      maxConcurrent: 3,
+      timeout: 6e5
+    },
+    remoteCache: {
+      dir: "/tmp/openspec-stat-cache",
+      autoCleanup: true,
+      cleanupOnComplete: true,
+      cleanupOnError: true
+    }
+  };
+}
+function saveConfig(path, config) {
+  (0, import_fs.writeFileSync)(path, JSON.stringify(config, null, 2));
+}
+var SINGLE_REPO_TEMPLATE = {
+  defaultBranches: ["origin/master"],
+  defaultSinceHours: -30,
+  defaultUntilHours: 20,
+  authorMapping: {
+    "user@email1.com": "User Name",
+    "user@email2.com": "User Name"
+  },
+  openspecDir: "openspec/",
+  excludeExtensions: [".md", ".txt", ".png", ".jpg"],
+  activeUserWeeks: 2
+};
+var MULTI_REPO_TEMPLATE = {
+  mode: "multi-repo",
+  repositories: [
+    {
+      name: "example-local-repo",
+      type: "local",
+      path: "./path/to/repo",
+      branches: ["origin/master"]
+    },
+    {
+      name: "example-remote-repo",
+      type: "remote",
+      url: "git@github.com:org/repo.git",
+      branches: ["origin/main"],
+      cloneOptions: {
+        depth: null,
+        singleBranch: false
+      }
+    }
+  ],
+  defaultSinceHours: -30,
+  defaultUntilHours: 20,
+  authorMapping: {},
+  openspecDir: "openspec/",
+  excludeExtensions: [".md", ".txt", ".png", ".jpg"],
+  activeUserWeeks: 2,
+  parallelism: {
+    maxConcurrent: 3,
+    timeout: 6e5
+  },
+  remoteCache: {
+    dir: "/tmp/openspec-stat-cache",
+    autoCleanup: true,
+    cleanupOnComplete: true,
+    cleanupOnError: true
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MULTI_REPO_TEMPLATE,
+  SINGLE_REPO_TEMPLATE,
+  runConfigWizard
+});

package/dist/cjs/multi/multi-repo-analyzer.d.ts

@@ -0,0 +1,14 @@
+import { MultiRepoConfig, RepositoryResult } from '../types.js';
+export declare class MultiRepoAnalyzer {
+    private config;
+    private tempDirs;
+    constructor(config: MultiRepoConfig);
+    analyzeAll(since: Date, until: Date): Promise<RepositoryResult[]>;
+    private analyzeRepository;
+    private cloneRemoteRepository;
+    private resolveLocalPath;
+    private processInBatches;
+    private withTimeout;
+    cleanupTempDirs(): Promise<void>;
+    registerCleanupHandlers(): void;
+}

package/dist/cjs/multi/multi-repo-analyzer.js

@@ -0,0 +1,210 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/multi/multi-repo-analyzer.ts
+var multi_repo_analyzer_exports = {};
+__export(multi_repo_analyzer_exports, {
+  MultiRepoAnalyzer: () => MultiRepoAnalyzer
+});
+module.exports = __toCommonJS(multi_repo_analyzer_exports);
+var import_simple_git = __toESM(require("simple-git"));
+var import_fs = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+var import_chalk = __toESM(require("chalk"));
+var import_git_analyzer = require("../git-analyzer.js");
+var import_i18n = require("../i18n/index.js");
+var MultiRepoAnalyzer = class {
+  constructor(config) {
+    this.tempDirs = /* @__PURE__ */ new Set();
+    this.config = config;
+  }
+  async analyzeAll(since, until) {
+    var _a, _b;
+    const repos = this.config.repositories || [];
+    const enabledRepos = repos.filter((r) => r.enabled !== false);
+    try {
+      const results = await this.processInBatches(
+        enabledRepos,
+        (repo) => this.analyzeRepository(repo, since, until),
+        ((_a = this.config.parallelism) == null ? void 0 : _a.maxConcurrent) || 3
+      );
+      return results;
+    } finally {
+      if ((_b = this.config.remoteCache) == null ? void 0 : _b.cleanupOnComplete) {
+        await this.cleanupTempDirs();
+      }
+    }
+  }
+  async analyzeRepository(repo, since, until) {
+    let repoPath;
+    try {
+      if (repo.enabled === false) {
+        console.log(import_chalk.default.gray((0, import_i18n.t)("multi.repo.skipped", { repo: repo.name })));
+        return {
+          repository: repo.name,
+          type: repo.type,
+          path: "",
+          analyses: [],
+          success: false,
+          error: "disabled"
+        };
+      }
+      console.log(import_chalk.default.blue((0, import_i18n.t)("multi.repo.analyzing", { repo: repo.name, type: repo.type })));
+      if (repo.type === "local") {
+        repoPath = this.resolveLocalPath(repo.path);
+        if (!(0, import_fs.existsSync)((0, import_path.join)(repoPath, ".git"))) {
+          throw new Error(`Not a git repository: ${repoPath}`);
+        }
+      } else {
+        repoPath = await this.cloneRemoteRepository(repo);
+      }
+      const analyzer = new import_git_analyzer.GitAnalyzer(repoPath, this.config);
+      if (repo.type === "local" && this.config.autoFetch !== false) {
+        console.log(import_chalk.default.cyan((0, import_i18n.t)("multi.repo.fetching", { repo: repo.name })));
+        await analyzer.fetchRemote();
+      }
+      const commits = await analyzer.getCommits(since, until, repo.branches);
+      const analyses = [];
+      for (const commit of commits) {
+        const analysis = await analyzer.analyzeCommit(commit);
+        if (analysis) {
+          analysis.repository = repo.name;
+          analysis.repositoryType = repo.type;
+          analyses.push(analysis);
+        }
+      }
+      console.log(import_chalk.default.green((0, import_i18n.t)("multi.repo.completed", { repo: repo.name, commits: String(analyses.length) })));
+      return {
+        repository: repo.name,
+        type: repo.type,
+        path: repoPath,
+        analyses,
+        success: true
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(import_chalk.default.red((0, import_i18n.t)("multi.repo.failed", { repo: repo.name, error: errorMessage })));
+      return {
+        repository: repo.name,
+        type: repo.type,
+        path: "",
+        analyses: [],
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  async cloneRemoteRepository(repo) {
+    var _a, _b, _c, _d, _e;
+    const cacheDir = ((_a = this.config.remoteCache) == null ? void 0 : _a.dir) || (0, import_path.join)((0, import_os.tmpdir)(), "openspec-stat-cache");
+    if (!(0, import_fs.existsSync)(cacheDir)) {
+      (0, import_fs.mkdirSync)(cacheDir, { recursive: true });
+    }
+    const tempDir = (0, import_fs.mkdtempSync)((0, import_path.join)(cacheDir, `${repo.name}-`));
+    this.tempDirs.add(tempDir);
+    console.log(import_chalk.default.cyan((0, import_i18n.t)("multi.repo.cloning", { repo: repo.name })));
+    const git = (0, import_simple_git.default)();
+    const cloneArgs = [];
+    if (((_b = repo.cloneOptions) == null ? void 0 : _b.depth) !== null && ((_c = repo.cloneOptions) == null ? void 0 : _c.depth) !== void 0) {
+      cloneArgs.push(`--depth=${repo.cloneOptions.depth}`);
+    }
+    if ((_d = repo.cloneOptions) == null ? void 0 : _d.singleBranch) {
+      cloneArgs.push("--single-branch");
+    }
+    const timeout = ((_e = this.config.parallelism) == null ? void 0 : _e.timeout) || 6e5;
+    await this.withTimeout(git.clone(repo.url, tempDir, cloneArgs), timeout, `Clone timeout for ${repo.name}`);
+    console.log(import_chalk.default.green((0, import_i18n.t)("multi.repo.cloned", { repo: repo.name })));
+    return tempDir;
+  }
+  resolveLocalPath(path) {
+    if (path.startsWith("/") || path.match(/^[A-Za-z]:\\/)) {
+      return path;
+    }
+    return (0, import_path.resolve)(process.cwd(), path);
+  }
+  async processInBatches(items, processor, concurrency) {
+    const results = [];
+    for (let i = 0; i < items.length; i += concurrency) {
+      const batch = items.slice(i, i + concurrency);
+      const batchNumber = Math.floor(i / concurrency) + 1;
+      const totalBatches = Math.ceil(items.length / concurrency);
+      if (totalBatches > 1) {
+        console.log(
+          import_chalk.default.gray((0, import_i18n.t)("multi.progress.batch", { current: String(batchNumber), total: String(totalBatches) }))
+        );
+      }
+      const batchResults = await Promise.all(batch.map(processor));
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  async withTimeout(promise, timeout, errorMessage) {
+    return Promise.race([
+      promise,
+      new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeout))
+    ]);
+  }
+  async cleanupTempDirs() {
+    if (this.tempDirs.size === 0) {
+      return;
+    }
+    console.log(import_chalk.default.gray((0, import_i18n.t)("multi.cleanup.start")));
+    for (const dir of this.tempDirs) {
+      try {
+        if ((0, import_fs.existsSync)(dir)) {
+          (0, import_fs.rmSync)(dir, { recursive: true, force: true });
+        }
+      } catch (error) {
+        console.warn(`Failed to cleanup ${dir}:`, error);
+      }
+    }
+    this.tempDirs.clear();
+    console.log(import_chalk.default.green((0, import_i18n.t)("multi.cleanup.done")));
+  }
+  registerCleanupHandlers() {
+    const cleanup = async () => {
+      var _a;
+      if ((_a = this.config.remoteCache) == null ? void 0 : _a.autoCleanup) {
+        await this.cleanupTempDirs();
+      }
+    };
+    process.once("SIGINT", async () => {
+      await cleanup();
+      process.exit(130);
+    });
+    process.once("SIGTERM", async () => {
+      await cleanup();
+      process.exit(143);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultiRepoAnalyzer
+});

package/dist/cjs/types.d.ts

@@ -7,6 +7,7 @@ export interface Config {
     codeFileExtensions?: string[];
     excludeExtensions?: string[];
     activeUserWeeks?: number;
+    autoFetch?: boolean;
 }
 export interface CliOptions {
     repo: string;
@@ -21,6 +22,7 @@ export interface CliOptions {
     verbose?: boolean;
     interactive?: boolean;
     lang?: string;
+    noFetch?: boolean;
 }
 export interface CommitInfo {
     hash: string;
@@ -86,3 +88,47 @@ export interface StatsResult {
     proposals: Map<string, ProposalStats>;
     totalCommits: number;
 }
+export interface RepositoryConfig {
+    name: string;
+    type: 'local' | 'remote';
+    path?: string;
+    url?: string;
+    cloneOptions?: {
+        depth?: number | null;
+        singleBranch?: boolean;
+    };
+    branches: string[];
+    enabled?: boolean;
+}
+export interface RemoteCacheConfig {
+    dir: string;
+    autoCleanup: boolean;
+    cleanupOnComplete: boolean;
+    cleanupOnError: boolean;
+}
+export interface ParallelismConfig {
+    maxConcurrent: number;
+    timeout: number;
+}
+export interface MultiRepoConfig extends Config {
+    mode: 'single-repo' | 'multi-repo';
+    repositories?: RepositoryConfig[];
+    remoteCache?: RemoteCacheConfig;
+    parallelism?: ParallelismConfig;
+}
+export interface RepositoryResult {
+    repository: string;
+    type: 'local' | 'remote';
+    path: string;
+    analyses: CommitAnalysis[];
+    success: boolean;
+    error?: string;
+}
+export interface MultiRepoStatsResult extends StatsResult {
+    repositories: string[];
+    repositoryDetails: Map<string, {
+        type: 'local' | 'remote';
+        commits: number;
+        error?: string;
+    }>;
+}