@open-agent-toolkit/cli 0.0.10

package/dist/commands/remove/skill/remove-skill.js

@@ -0,0 +1,231 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildCommandContext } from '../../../app/command-context.js';
+import { readGlobalOptions, resolveConcreteScopes, } from '../../shared/shared.utils.js';
+import { DEFAULT_SYNC_CONFIG, loadSyncConfig, } from '../../../config/sync-config.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { resolveProjectRoot, resolveScopeRoot } from '../../../fs/paths.js';
+import { loadManifest, removeEntry, saveManifest, } from '../../../manifest/index.js';
+import { claudeAdapter } from '../../../providers/claude/index.js';
+import { codexAdapter } from '../../../providers/codex/index.js';
+import { copilotAdapter } from '../../../providers/copilot/index.js';
+import { cursorAdapter } from '../../../providers/cursor/index.js';
+import { geminiAdapter } from '../../../providers/gemini/index.js';
+import { getConfigAwareAdapters, getSyncMappings, } from '../../../providers/shared/index.js';
+import { Command } from 'commander';
+export function createDefaultRemoveSkillDependencies() {
+    return {
+        buildCommandContext,
+        async resolveScopeRoot(scope, context) {
+            if (scope === 'project') {
+                return resolveProjectRoot(context.cwd);
+            }
+            return resolveScopeRoot(scope, context.cwd, context.home);
+        },
+        loadManifest,
+        saveManifest,
+        async loadSyncConfig(configPath) {
+            return loadSyncConfig(configPath, DEFAULT_SYNC_CONFIG);
+        },
+        getAdapters() {
+            return [
+                claudeAdapter,
+                cursorAdapter,
+                codexAdapter,
+                copilotAdapter,
+                geminiAdapter,
+            ];
+        },
+        getConfigAwareAdapters,
+        getSyncMappings,
+        async pathExists(path) {
+            return (await fileExists(path)) || (await dirExists(path));
+        },
+        async removeDirectory(path) {
+            await rm(path, { recursive: true, force: true });
+        },
+    };
+}
+function dedupeViews(views) {
+    const seen = new Set();
+    return views.filter((view) => {
+        const key = `${view.provider}::${view.relativePath}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+async function buildScopePlan(scope, scopeRoot, skillName, dependencies) {
+    const canonicalRelativePath = `.agents/skills/${skillName}`;
+    const canonicalAbsolutePath = join(scopeRoot, '.agents', 'skills', skillName);
+    const canonicalExists = await dependencies.pathExists(canonicalAbsolutePath);
+    if (!canonicalExists) {
+        return null;
+    }
+    const manifestPath = join(scopeRoot, '.oat', 'sync', 'manifest.json');
+    const configPath = join(scopeRoot, '.oat', 'sync', 'config.json');
+    const [manifest, config] = await Promise.all([
+        dependencies.loadManifest(manifestPath),
+        dependencies.loadSyncConfig(configPath),
+    ]);
+    const adapters = dependencies.getAdapters();
+    const { activeAdapters } = await dependencies.getConfigAwareAdapters(adapters, scopeRoot, config);
+    const managedProviderViews = [];
+    const unmanagedProviderViews = [];
+    for (const adapter of activeAdapters) {
+        const mappings = dependencies
+            .getSyncMappings(adapter, scope)
+            .filter((mapping) => mapping.contentType === 'skill');
+        for (const mapping of mappings) {
+            const relativePath = join(mapping.providerDir, skillName);
+            const absolutePath = join(scopeRoot, relativePath);
+            const hasManifestEntry = manifest.entries.some((entry) => entry.canonicalPath === canonicalRelativePath &&
+                entry.provider === adapter.name);
+            const providerPathExists = await dependencies.pathExists(absolutePath);
+            if (hasManifestEntry) {
+                managedProviderViews.push({
+                    provider: adapter.name,
+                    absolutePath,
+                    relativePath,
+                });
+                continue;
+            }
+            if (providerPathExists) {
+                unmanagedProviderViews.push({
+                    provider: adapter.name,
+                    absolutePath,
+                    relativePath,
+                });
+            }
+        }
+    }
+    return {
+        scope,
+        scopeRoot,
+        manifestPath,
+        manifest,
+        canonicalRelativePath,
+        canonicalAbsolutePath,
+        managedProviderViews: dedupeViews(managedProviderViews),
+        unmanagedProviderViews: dedupeViews(unmanagedProviderViews),
+    };
+}
+function logDryRun(context, plan) {
+    context.logger.info(`[dry-run][${plan.scope}] remove ${plan.canonicalRelativePath}`);
+    if (plan.managedProviderViews.length > 0) {
+        context.logger.info(`[dry-run][${plan.scope}] managed provider views:`);
+        for (const view of plan.managedProviderViews) {
+            context.logger.info(`  - ${view.provider}: ${view.relativePath}`);
+        }
+    }
+    if (plan.unmanagedProviderViews.length > 0) {
+        context.logger.warn(`[dry-run][${plan.scope}] unmanaged provider views (not deleted):`);
+        for (const view of plan.unmanagedProviderViews) {
+            context.logger.warn(`  - ${view.provider}: ${view.relativePath}`);
+        }
+    }
+}
+function toJsonScopeResults(plans) {
+    return plans.map((plan) => ({
+        scope: plan.scope,
+        canonicalPath: plan.canonicalRelativePath,
+        managedProviderViews: plan.managedProviderViews
+            .map((view) => view.relativePath)
+            .sort(),
+        unmanagedProviderViews: plan.unmanagedProviderViews
+            .map((view) => view.relativePath)
+            .sort(),
+    }));
+}
+async function applyPlan(context, plan, dependencies) {
+    await dependencies.removeDirectory(plan.canonicalAbsolutePath);
+    for (const view of plan.managedProviderViews) {
+        await dependencies.removeDirectory(view.absolutePath);
+    }
+    let nextManifest = plan.manifest;
+    for (const view of plan.managedProviderViews) {
+        nextManifest = removeEntry(nextManifest, plan.canonicalRelativePath, view.provider);
+    }
+    await dependencies.saveManifest(plan.manifestPath, nextManifest);
+    context.logger.info(`[apply][${plan.scope}] removed ${plan.canonicalRelativePath}`);
+    if (plan.unmanagedProviderViews.length > 0) {
+        context.logger.warn(`[apply][${plan.scope}] unmanaged provider views preserved:`);
+        for (const view of plan.unmanagedProviderViews) {
+            context.logger.warn(`  - ${view.provider}: ${view.relativePath}`);
+        }
+    }
+}
+export async function runRemoveSkill(context, skillName, dryRun, dependencies) {
+    const scopes = resolveConcreteScopes(context.scope);
+    const plans = [];
+    for (const scope of scopes) {
+        const scopeRoot = await dependencies.resolveScopeRoot(scope, context);
+        const plan = await buildScopePlan(scope, scopeRoot, skillName, dependencies);
+        if (plan) {
+            plans.push(plan);
+        }
+    }
+    if (plans.length === 0) {
+        const message = `Skill not found in selected scope(s): ${skillName}`;
+        if (context.json) {
+            context.logger.json({ status: 'not_found', skill: skillName });
+        }
+        else {
+            context.logger.warn(message);
+        }
+        return false;
+    }
+    if (dryRun) {
+        for (const plan of plans) {
+            logDryRun(context, plan);
+        }
+        if (context.json) {
+            context.logger.json({
+                status: 'dry_run',
+                skill: skillName,
+                scopes: toJsonScopeResults(plans),
+            });
+        }
+        return true;
+    }
+    for (const plan of plans) {
+        await applyPlan(context, plan, dependencies);
+    }
+    if (context.json) {
+        context.logger.json({
+            status: 'removed',
+            skill: skillName,
+            scopes: toJsonScopeResults(plans),
+        });
+    }
+    return true;
+}
+export function createRemoveSkillCommand(overrides = {}) {
+    const dependencies = {
+        ...createDefaultRemoveSkillDependencies(),
+        ...overrides,
+    };
+    return new Command('skill')
+        .description('Remove a single installed skill by name')
+        .argument('<name>', 'Skill name (e.g., oat-idea-scratchpad)')
+        .option('--dry-run', 'Preview removal without applying')
+        .action(async (skillName, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const removed = await runRemoveSkill(context, skillName, options.dryRun ?? false, dependencies);
+            process.exitCode = removed ? 0 : 1;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (context.json) {
+                context.logger.json({ status: 'error', message });
+            }
+            else {
+                context.logger.error(message);
+            }
+            process.exitCode = 2;
+        }
+    });
+}

package/dist/commands/remove/skills/index.d.ts

@@ -0,0 +1,2 @@
+export { createRemoveSkillsCommand } from './remove-skills.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/remove/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/remove/skills/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/commands/remove/skills/index.js

@@ -0,0 +1 @@
+export { createRemoveSkillsCommand } from './remove-skills.js';

package/dist/commands/remove/skills/remove-skills.d.ts

@@ -0,0 +1,14 @@
+import { type CommandContext } from '../../../app/command-context.js';
+import { type PromptContext } from '../../shared/shared.prompts.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { Command } from 'commander';
+import { type RemoveSkillDependencies } from '../skill/remove-skill.js';
+interface RemoveSkillsDependencies {
+    buildCommandContext: (options: ReturnType<typeof readGlobalOptions>) => CommandContext;
+    confirmAction: (message: string, ctx: PromptContext) => Promise<boolean>;
+    runRemoveSkill: (context: CommandContext, skillName: string, dryRun: boolean, dependencies: RemoveSkillDependencies) => Promise<boolean>;
+    removeSkillDependencies: RemoveSkillDependencies;
+}
+export declare function createRemoveSkillsCommand(overrides?: Partial<RemoveSkillsDependencies>): Command;
+export {};
+//# sourceMappingURL=remove-skills.d.ts.map

package/dist/commands/remove/skills/remove-skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-skills.d.ts","sourceRoot":"","sources":["../../../../src/commands/remove/skills/remove-skills.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAMhF,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,uBAAuB,EAE7B,MAAM,uBAAuB,CAAC;AAiB/B,UAAU,wBAAwB;IAChC,mBAAmB,EAAE,CACnB,OAAO,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,KAC1C,cAAc,CAAC;IACpB,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACzE,cAAc,EAAE,CACd,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,uBAAuB,KAClC,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,uBAAuB,EAAE,uBAAuB,CAAC;CAClD;AAqBD,wBAAgB,yBAAyB,CACvC,SAAS,GAAE,OAAO,CAAC,wBAAwB,CAAM,GAChD,OAAO,CAsFT"}

package/dist/commands/remove/skills/remove-skills.js

@@ -0,0 +1,98 @@
+import { buildCommandContext } from '../../../app/command-context.js';
+import { DOCS_SKILLS } from '../../init/tools/docs/install-docs.js';
+import { IDEA_SKILLS } from '../../init/tools/ideas/install-ideas.js';
+import { RESEARCH_SKILLS } from '../../init/tools/research/install-research.js';
+import { UTILITY_SKILLS } from '../../init/tools/utility/install-utility.js';
+import { WORKFLOW_SKILLS } from '../../init/tools/workflows/install-workflows.js';
+import { confirmAction, } from '../../shared/shared.prompts.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { Command } from 'commander';
+import { createDefaultRemoveSkillDependencies, runRemoveSkill, } from '../skill/remove-skill.js';
+const PACK_SKILLS = {
+    ideas: IDEA_SKILLS,
+    docs: DOCS_SKILLS,
+    workflows: WORKFLOW_SKILLS,
+    utility: UTILITY_SKILLS,
+    research: RESEARCH_SKILLS,
+};
+function createDependencies() {
+    return {
+        buildCommandContext,
+        confirmAction,
+        runRemoveSkill,
+        removeSkillDependencies: createDefaultRemoveSkillDependencies(),
+    };
+}
+function isPackName(value) {
+    return (value === 'ideas' ||
+        value === 'docs' ||
+        value === 'workflows' ||
+        value === 'utility' ||
+        value === 'research');
+}
+export function createRemoveSkillsCommand(overrides = {}) {
+    const dependencies = {
+        ...createDependencies(),
+        ...overrides,
+    };
+    return new Command('skills')
+        .description('Remove installed skills by pack')
+        .requiredOption('--pack <pack>', 'Skill pack to remove (ideas|docs|workflows|utility|research)')
+        .option('--dry-run', 'Preview removal without applying')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const rawPack = (options.pack ?? '').toLowerCase();
+            if (!isPackName(rawPack)) {
+                throw new Error(`Invalid pack: ${options.pack}. Expected one of: ideas, docs, workflows, utility, research.`);
+            }
+            const skills = [...PACK_SKILLS[rawPack]];
+            if (context.interactive && skills.length > 3) {
+                const confirmed = await dependencies.confirmAction(`Remove ${skills.length} skills from pack '${rawPack}'?`, { interactive: context.interactive });
+                if (!confirmed) {
+                    if (!context.json) {
+                        context.logger.info('Removal cancelled.');
+                    }
+                    process.exitCode = 0;
+                    return;
+                }
+            }
+            let removedCount = 0;
+            let skippedCount = 0;
+            const executionContext = context.json
+                ? { ...context, json: false }
+                : context;
+            for (const skillName of skills) {
+                const removed = await dependencies.runRemoveSkill(executionContext, skillName, options.dryRun ?? false, dependencies.removeSkillDependencies);
+                if (removed) {
+                    removedCount += 1;
+                }
+                else {
+                    skippedCount += 1;
+                }
+            }
+            if (context.json) {
+                context.logger.json({
+                    status: 'ok',
+                    pack: rawPack,
+                    removedCount,
+                    skippedCount,
+                });
+            }
+            else {
+                context.logger.info(`Pack '${rawPack}' processed. Removed: ${removedCount}. Skipped: ${skippedCount}.`);
+            }
+            process.exitCode = 0;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (context.json) {
+                context.logger.json({ status: 'error', message });
+            }
+            else {
+                context.logger.error(message);
+            }
+            process.exitCode = 2;
+        }
+    });
+}

package/dist/commands/repo/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createRepoCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/repo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/repo/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,wBAAgB,iBAAiB,IAAI,OAAO,CAQ3C"}

package/dist/commands/repo/index.js

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+import { createPrCommentsCommand } from './pr-comments/index.js';
+export function createRepoCommand() {
+    const cmd = new Command('repo').description('Repository-level analysis and insight tools');
+    cmd.addCommand(createPrCommentsCommand());
+    return cmd;
+}

package/dist/commands/repo/pr-comments/collect/collect-comments.d.ts

@@ -0,0 +1,9 @@
+import type { CommandContext } from '../../../../app/command-context.js';
+import type { CollectOptions } from './pr-comments.types.js';
+export interface CollectDependencies {
+    ghGraphQL: (query: string, variables: Record<string, unknown>) => Promise<unknown>;
+    resolveCurrentRepo: () => Promise<string>;
+}
+export declare const defaultCollectDependencies: CollectDependencies;
+export declare function runCollectComments(context: CommandContext, options: CollectOptions, deps?: CollectDependencies): Promise<void>;
+//# sourceMappingURL=collect-comments.d.ts.map

package/dist/commands/repo/pr-comments/collect/collect-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-comments.d.ts","sourceRoot":"","sources":["../../../../../src/commands/repo/pr-comments/collect/collect-comments.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAO3D,OAAO,KAAK,EACV,cAAc,EAOf,MAAM,qBAAqB,CAAC;AAyC7B,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,CACT,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC/B,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,kBAAkB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAgCxC,CAAC;AAEF,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,cAAc,EACvB,IAAI,GAAE,mBAAgD,GACrD,OAAO,CAAC,IAAI,CAAC,CA2Ef"}

package/dist/commands/repo/pr-comments/collect/collect-comments.js

@@ -0,0 +1,284 @@
+import { execFile } from 'node:child_process';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { ensureDir } from '../../../../fs/io.js';
+import { REVIEW_COMMENTS_PAGE_QUERY, SEARCH_MERGED_PRS_QUERY, } from './graphql-queries.js';
+const execFileAsync = promisify(execFile);
+const TRIVIAL_BODY_PATTERNS = [
+    /^lgtm\.?$/i,
+    /^nit\.?$/i,
+    /^\+1$/,
+    /^:thumbsup:$/,
+    /^👍+$/,
+    /^looks good\.?$/i,
+    /^looks good to me\.?$/i,
+    /^ship it\.?$/i,
+    /^:shipit:$/,
+    /^nice!?$/i,
+    /^great!?$/i,
+    /^thanks!?$/i,
+    /^thank you!?$/i,
+];
+const KNOWN_BOT_LOGINS = new Set([
+    'coderabbitai',
+    'copilot',
+    'sourcery-ai',
+    'vercel',
+    'supabase',
+    'codacy-production',
+    'sonarcloud',
+    'codecov',
+    'netlify',
+    'linear',
+    'changeset-bot',
+    'renovate',
+    'dependabot',
+    'snyk-bot',
+]);
+const TRIVIAL_WORD_THRESHOLD = 5;
+const CODE_REFERENCE_PATTERN = /`[^`]+`|[\w/]+\.\w{1,5}:\d+|line \d+/i;
+export const defaultCollectDependencies = {
+    ghGraphQL: async (query, variables) => {
+        const args = ['api', 'graphql', '-f', `query=${query}`];
+        for (const [key, value] of Object.entries(variables)) {
+            if (typeof value === 'number') {
+                args.push('-F', `${key}=${value}`);
+            }
+            else {
+                args.push('-f', `${key}=${String(value)}`);
+            }
+        }
+        const { stdout } = await execFileAsync('gh', args, {
+            maxBuffer: 50 * 1024 * 1024,
+        });
+        return JSON.parse(stdout);
+    },
+    resolveCurrentRepo: async () => {
+        const { stdout } = await execFileAsync('git', [
+            'remote',
+            'get-url',
+            'origin',
+        ]);
+        const url = stdout.trim();
+        // Handle SSH (git@github.com:owner/name.git) and HTTPS (https://github.com/owner/name.git)
+        // Allow dots in repo names (e.g., owner/repo.name)
+        const sshMatch = url.match(/git@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
+        if (sshMatch?.[1])
+            return sshMatch[1];
+        const httpsMatch = url.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
+        if (httpsMatch?.[1])
+            return httpsMatch[1];
+        throw new Error(`Could not parse repository owner/name from git remote URL: ${url}`);
+    },
+};
+export async function runCollectComments(context, options, deps = defaultCollectDependencies) {
+    const { logger } = context;
+    const { since, until, outDir, ignoreBots } = options;
+    let { repo } = options;
+    const untilDate = until ?? new Date().toISOString().slice(0, 10);
+    if (!repo) {
+        logger.debug('No --repo provided, resolving from git remote…');
+        try {
+            repo = await deps.resolveCurrentRepo();
+            logger.info(`Resolved repository: ${repo}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`--repo not provided and could not resolve current repository: ${message}`, { cause: error });
+        }
+    }
+    logger.info(`Collecting PR review comments from ${since} to ${untilDate}...`);
+    const repoQualifier = `repo:${repo}`;
+    const allComments = await fetchAllComments(deps, logger, repoQualifier, since, untilDate, ignoreBots, repo);
+    if (allComments.length === 0) {
+        logger.warn('No review comments found in the specified date range.');
+        if (context.json) {
+            logger.json({ status: 'ok', comments: 0, chunks: [] });
+        }
+        return;
+    }
+    logger.info(`Found ${allComments.length} review comments.`);
+    const indexed = assignIds(allComments);
+    const chunks = groupByMonth(indexed);
+    await ensureDir(outDir);
+    const writtenFiles = [];
+    for (const chunk of chunks) {
+        const jsonPath = join(outDir, `${chunk.month}.json`);
+        const mdPath = join(outDir, `${chunk.month}.md`);
+        await writeFile(jsonPath, `${JSON.stringify(chunk, null, 2)}\n`, 'utf8');
+        await writeFile(mdPath, renderMarkdown(chunk), 'utf8');
+        writtenFiles.push(jsonPath, mdPath);
+        logger.info(`  ${chunk.month}: ${chunk.comments.length} comments`);
+    }
+    logger.success(`Collected ${allComments.length} comments across ${chunks.length} month(s) → ${outDir}`);
+    if (context.json) {
+        logger.json({
+            status: 'ok',
+            comments: allComments.length,
+            chunks: chunks.map((c) => ({ month: c.month, count: c.comments.length })),
+            outputDir: outDir,
+            files: writtenFiles,
+        });
+    }
+}
+async function fetchAllComments(deps, logger, repoQualifier, since, until, ignoreBots, repo) {
+    const comments = [];
+    let cursor = null;
+    let page = 0;
+    const searchQuery = [
+        'is:pr',
+        'is:merged',
+        `merged:${since}..${until}`,
+        repoQualifier,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    logger.debug(`GraphQL search query: ${searchQuery}`);
+    // Parse owner/name for paginating review comments
+    const repoParts = repo?.split('/');
+    const owner = repoParts?.[0];
+    const name = repoParts?.[1];
+    while (true) {
+        page++;
+        logger.debug(`Fetching PR page ${page}...`);
+        const variables = {
+            searchQuery,
+            first: 25,
+        };
+        if (cursor) {
+            variables.after = cursor;
+        }
+        const result = (await deps.ghGraphQL(SEARCH_MERGED_PRS_QUERY, variables));
+        const searchData = result.data.search;
+        for (const pr of searchData.nodes) {
+            const prComments = await collectPrComments(deps, pr, owner, name);
+            const filtered = filterComments(prComments, pr, ignoreBots);
+            comments.push(...filtered);
+        }
+        if (!searchData.pageInfo.hasNextPage) {
+            break;
+        }
+        cursor = searchData.pageInfo.endCursor;
+    }
+    return comments;
+}
+async function collectPrComments(deps, pr, owner, name) {
+    const results = pr.reviewComments.nodes.map((c) => ({ pr, comment: c }));
+    // Paginate if there are more comments
+    if (pr.reviewComments.pageInfo.hasNextPage && owner && name) {
+        let commentCursor = pr.reviewComments.pageInfo.endCursor;
+        while (commentCursor) {
+            const pageResult = (await deps.ghGraphQL(REVIEW_COMMENTS_PAGE_QUERY, {
+                prNumber: pr.number,
+                owner,
+                name,
+                first: 100,
+                after: commentCursor,
+            }));
+            const page = pageResult.data.repository.pullRequest.reviewComments;
+            for (const c of page.nodes) {
+                results.push({ pr, comment: c });
+            }
+            commentCursor = page.pageInfo.hasNextPage
+                ? page.pageInfo.endCursor
+                : null;
+        }
+    }
+    return results;
+}
+function isBot(comment) {
+    const login = comment.author?.login ?? '';
+    // Layer 1: GitHub API author type
+    if (comment.author?.__typename === 'Bot')
+        return true;
+    // Layer 2: Known bot login suffix
+    if (login.endsWith('[bot]'))
+        return true;
+    // Layer 3: Known service logins
+    if (KNOWN_BOT_LOGINS.has(login.toLowerCase()))
+        return true;
+    return false;
+}
+function isTrivialComment(body) {
+    // Exact pattern matches (emoji-only, known phrases)
+    if (TRIVIAL_BODY_PATTERNS.some((p) => p.test(body)))
+        return true;
+    // Emoji-only comments (Unicode emoji sequences)
+    if (/^\p{Emoji_Presentation}+$/u.test(body))
+        return true;
+    // Short comments under word threshold — unless they reference code
+    const wordCount = body.split(/\s+/).length;
+    if (wordCount < TRIVIAL_WORD_THRESHOLD && !CODE_REFERENCE_PATTERN.test(body))
+        return true;
+    return false;
+}
+function filterComments(items, _pr, ignoreBots) {
+    const results = [];
+    for (const { pr, comment } of items) {
+        const author = comment.author?.login ?? 'ghost';
+        const body = comment.body.trim();
+        if (!body)
+            continue;
+        if (ignoreBots && isBot(comment))
+            continue;
+        if (isTrivialComment(body))
+            continue;
+        results.push({
+            id: comment.id,
+            prNumber: pr.number,
+            prTitle: pr.title,
+            prAuthor: pr.author?.login ?? 'ghost',
+            prMergedAt: pr.mergedAt,
+            filePath: comment.path,
+            line: comment.line,
+            author,
+            body,
+            createdAt: comment.createdAt,
+            url: comment.url,
+        });
+    }
+    return results;
+}
+function assignIds(comments) {
+    const sorted = [...comments].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    return sorted.map((c, i) => ({
+        ...c,
+        rcId: `RC-${String(i + 1).padStart(3, '0')}`,
+    }));
+}
+function groupByMonth(comments) {
+    const groups = new Map();
+    for (const c of comments) {
+        const month = c.prMergedAt.slice(0, 7); // YYYY-MM from PR merge date
+        const existing = groups.get(month);
+        if (existing) {
+            existing.push(c);
+        }
+        else {
+            groups.set(month, [c]);
+        }
+    }
+    return [...groups.entries()]
+        .sort(([a], [b]) => b.localeCompare(a))
+        .map(([month, monthComments]) => ({ month, comments: monthComments }));
+}
+function renderMarkdown(chunk) {
+    const lines = [`# Review Comments — ${chunk.month}`, ''];
+    for (const c of chunk.comments) {
+        lines.push(`## ${c.rcId}: PR #${c.prNumber} — ${c.prTitle}`);
+        lines.push('');
+        lines.push(`- **Author:** ${c.author}`);
+        lines.push(`- **File:** \`${c.filePath}\`${c.line ? `:${c.line}` : ''}`);
+        lines.push(`- **Date:** ${c.createdAt.slice(0, 10)}`);
+        lines.push(`- **URL:** ${c.url}`);
+        lines.push('');
+        lines.push('````');
+        lines.push(c.body);
+        lines.push('````');
+        lines.push('');
+        lines.push('---');
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/commands/repo/pr-comments/collect/graphql-queries.d.ts

@@ -0,0 +1,3 @@
+export declare const SEARCH_MERGED_PRS_QUERY = "\nquery($searchQuery: String!, $first: Int!, $after: String) {\n  search(query: $searchQuery, type: ISSUE, first: $first, after: $after) {\n    nodes {\n      ... on PullRequest {\n        number\n        title\n        mergedAt\n        author { login }\n        reviewComments(first: 100) {\n          nodes {\n            id\n            body\n            createdAt\n            url\n            path\n            line\n            author { login __typename }\n          }\n          pageInfo {\n            hasNextPage\n            endCursor\n          }\n        }\n      }\n    }\n    pageInfo {\n      hasNextPage\n      endCursor\n    }\n  }\n}\n";
+export declare const REVIEW_COMMENTS_PAGE_QUERY = "\nquery($prNumber: Int!, $owner: String!, $name: String!, $first: Int!, $after: String) {\n  repository(owner: $owner, name: $name) {\n    pullRequest(number: $prNumber) {\n      reviewComments(first: $first, after: $after) {\n        nodes {\n          id\n          body\n          createdAt\n          url\n          path\n          line\n          author { login __typename }\n        }\n        pageInfo {\n          hasNextPage\n          endCursor\n        }\n      }\n    }\n  }\n}\n";
+//# sourceMappingURL=graphql-queries.d.ts.map