edsger 0.54.0 → 0.55.0

package/dist/api/issues/update-issue.js

@@ -29,6 +29,12 @@ export async function updateIssue(issueId, updates, verbose) {
 export async function updateTechnicalDesign(issueId, technicalDesign, verbose) {
     return updateIssue(issueId, { technical_design: technicalDesign }, verbose);
 }
+/**
+ * Update execution plan for an issue
+ */
+export async function updateExecutionPlan(issueId, executionPlan, verbose) {
+    return updateIssue(issueId, { execution_plan: executionPlan }, verbose);
+}
 /**
  * Normalize phase name from pipeline format (hyphens) to workflow format (underscores)
  * e.g., 'issue-analysis' -> 'issue_analysis'

package/dist/commands/agent-workflow/processor.js

@@ -15,7 +15,7 @@ import { getGitHubConfig } from '../../api/github.js';
 import { WorkerTimeoutError } from '../../errors/index.js';
 import { sendHeartbeat, shouldProcess } from '../../system/session-manager.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneIssueRepo } from '../../workspace/workspace-manager.js';
+import { cleanupIssueRepo, cloneIssueRepo, getIssueRepoPath, } from '../../workspace/workspace-manager.js';
 import { calculateStats, createCompletedState, createFailedState, createInitialState, createProcessingState, updateIssueState, } from '../workflow/core/state-manager.js';
 /**
  * Maximum allowed concurrency (hard cap).
@@ -411,6 +411,10 @@ export class AgentWorkflowProcessor {
             logSuccess(`Issue completed: ${issueName}`);
             // Notify chat worker that issue workflow is done
             this.notifyChatWorker({ type: 'event:issue_done', issueId });
+            // Clean up the per-issue clone now that the workflow is finished.
+            // Failures intentionally leave the workspace so the user (or a retry)
+            // can inspect the partial state.
+            cleanupIssueRepo(getIssueRepoPath(this.options.workspaceRoot, issueId));
         }
         else {
             this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));

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

@@ -4,10 +4,13 @@
  */
 import { type CliOptions } from '../../types/index.js';
 /**
- * Run AI-powered checklist sync for a product based on local code analysis.
+ * Run AI-powered checklist sync. Scope is either a product (analyse the
+ * product's codebase) or a team (analyse team standards docs, generate
+ * org-wide checklists).
  */
 export declare function runChecklists(options: CliOptions & {
-    checklistsProductId: string;
+    checklistsProductId?: string;
+    checklistsTeamId?: string;
     checklistsDir?: string;
     checklistsPrompt?: string;
 }): Promise<void>;

package/dist/commands/checklists/index.js

@@ -20,7 +20,11 @@ function logAssistantContent(content) {
         }
     }
 }
-const SYSTEM_PROMPT = `You are an expert software quality engineer. Your job is to analyse the code and documentation in the current working directory and manage quality checklists for the product.
+// Two SYSTEM_PROMPTs because team-level sync has a different mental model:
+// the directory is reference material (org standards / process docs / shared
+// templates), not necessarily a product's own codebase. Telling the LLM
+// "scan the code" when there's no code wastes turns.
+const PRODUCT_SYSTEM_PROMPT = `You are an expert software quality engineer. Your job is to analyse the code and documentation in the current working directory and manage quality checklists for the product.
 
 ## Workflow
 
@@ -45,38 +49,95 @@ const SYSTEM_PROMPT = `You are an expert software quality engineer. Your job is
 - If the codebase is small, a few focused checklists are better than many sparse ones.
 - When creating multiple checklists, assign incrementing sort_order values (0, 1, 2, …) so they display in a meaningful order.
 `;
+const TEAM_SYSTEM_PROMPT = `You are an expert software quality engineer. Your job is to analyse the reference material in the current working directory (team standards, engineering guidelines, process docs, compliance requirements, shared templates, etc.) and manage TEAM-LEVEL quality checklists.
+
+Team checklists apply to every product owned by the team, so they should capture **organisation-wide** quality bars — not the specifics of any single codebase.
+
+## Workflow
+
+1. **Explore** the directory — read every relevant doc to understand the team's engineering standards, review process, security baseline, release rules, and other shared expectations. The directory is reference material, not necessarily product source code.
+2. **Query existing team checklists** using \`list_checklists\` so you know what already exists.
+3. **Decide what to change** — compare the standards documented in the directory against existing checklists:
+   - **Create** team checklists for standards that are not yet enforced (e.g., security baseline, release readiness, accessibility minimums, code-review etiquette).
+   - **Update** checklists whose items have drifted from the documented standards.
+   - **Delete** checklists that no longer reflect team policy.
+   - **Add / update / remove items** within checklists as needed.
+4. **Execute the changes** using the provided tools.
+5. **Summarise** what you did at the end.
+
+## Guidelines
+
+- Stay generic across products — a team checklist will apply to every product in the team, so do NOT bake in product-specific tech-stack assumptions.
+- Focus on actionable, verifiable checklist items — things a reviewer can check yes/no.
+- Assign the correct **role** to each checklist (developer, qa_engineer, technical_lead, etc.).
+- Assign relevant **phases** (code_implementation, code_review, technical_design, functional_testing, etc.).
+- Keep item titles concise (< 80 chars). Use the description for details.
+- Prefer boolean item_type for most items.
+- Do not create duplicate checklists — update existing ones instead.
+- When creating multiple checklists, assign incrementing sort_order values (0, 1, 2, …) so they display in a meaningful order.
+`;
 /**
- * Run AI-powered checklist sync for a product based on local code analysis.
+ * Run AI-powered checklist sync. Scope is either a product (analyse the
+ * product's codebase) or a team (analyse team standards docs, generate
+ * org-wide checklists).
  */
 export async function runChecklists(options) {
     const productId = options.checklistsProductId;
+    const teamId = options.checklistsTeamId;
     const directory = options.checklistsDir || process.cwd();
     const userPrompt = options.checklistsPrompt;
+    if (!productId && !teamId) {
+        throw new Error('checklists sync requires either a product ID or a team ID.');
+    }
+    if (productId && teamId) {
+        throw new Error('checklists sync received both a product ID and a team ID; choose one.');
+    }
+    const isTeamScope = !productId;
     if (!isLoggedIn()) {
         throw new Error('You must be logged in to run checklists sync.\n' +
             'Run `edsger login` first.');
     }
     // Validate configuration (ensures .edsgerrc and env are loaded)
     validateConfiguration(options);
-    // Register CLI session for log persistence
+    // Register CLI session for log persistence. We pass productId only when
+    // present so existing per-product session indexing still works.
     await registerSession({ command: 'checklists', productId });
-    logInfo(`Starting checklist sync for product: ${productId}`);
+    if (isTeamScope) {
+        logInfo(`Starting checklist sync for team: ${teamId}`);
+    }
+    else {
+        logInfo(`Starting checklist sync for product: ${productId}`);
+    }
     logInfo(`Analysing directory: ${directory}`);
     if (userPrompt) {
         logInfo(`User instructions: ${userPrompt}`);
     }
-    const mcpServer = createChecklistsMcpServer(productId);
-    const promptParts = [
-        `Analyse the codebase in the current working directory and synchronise the product's quality checklists.`,
-        `Product ID: ${productId}`,
-        `Directory: ${directory}`,
-        '',
-        'Start by exploring the project structure and reading key files, then query existing checklists, and finally create/update/delete as needed.',
-    ];
+    const mcpServer = isTeamScope
+        ? createChecklistsMcpServer({ kind: 'team', teamId: teamId })
+        : createChecklistsMcpServer({
+            kind: 'product',
+            productId: productId,
+        });
+    const promptParts = isTeamScope
+        ? [
+            `Analyse the reference material in the current working directory and synchronise the TEAM-LEVEL quality checklists.`,
+            `Team ID: ${teamId}`,
+            `Directory: ${directory}`,
+            '',
+            'Start by exploring the directory and reading every relevant standards / process / guideline document, then query existing team checklists, and finally create/update/delete as needed. Remember: team checklists apply to every product in the team, so keep them generic.',
+        ]
+        : [
+            `Analyse the codebase in the current working directory and synchronise the product's quality checklists.`,
+            `Product ID: ${productId}`,
+            `Directory: ${directory}`,
+            '',
+            'Start by exploring the project structure and reading key files, then query existing checklists, and finally create/update/delete as needed.',
+        ];
     if (userPrompt) {
         promptParts.push('', '## Additional Instructions from User', '', userPrompt);
     }
     const prompt = promptParts.join('\n');
+    const SYSTEM_PROMPT = isTeamScope ? TEAM_SYSTEM_PROMPT : PRODUCT_SYSTEM_PROMPT;
     try {
         for await (const message of query({
             prompt,

package/dist/commands/checklists/tools.d.ts

@@ -1,10 +1,17 @@
 /**
- * Checklist MCP tools for the Claude Agent SDK.
+ * Checklists MCP server — CLI entry point.
  *
- * Provides all checklist & checklist-item CRUD operations so the AI agent
- * can query, create, update, and delete checklists based on code analysis.
+ * Tool implementations live in `edsger-tools`. This shim adapts the CLI's
+ * `callMcpEndpoint` transport into `ToolDeps` and threads the scope id
+ * (productId or teamId) through `deps.context` so the CLI can run AI
+ * sync against either a product or a team.
  */
-/**
- * Create an in-process MCP server with checklist management tools.
- */
-export declare function createChecklistsMcpServer(productId: string): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
+import type { McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
+export type ChecklistScope = {
+    kind: 'product';
+    productId: string;
+} | {
+    kind: 'team';
+    teamId: string;
+};
+export declare function createChecklistsMcpServer(scope: ChecklistScope | string): McpSdkServerConfigWithInstance;

package/dist/commands/checklists/tools.js

@@ -1,212 +1,19 @@
 /**
- * Checklist MCP tools for the Claude Agent SDK.
+ * Checklists MCP server — CLI entry point.
  *
- * Provides all checklist & checklist-item CRUD operations so the AI agent
- * can query, create, update, and delete checklists based on code analysis.
+ * Tool implementations live in `edsger-tools`. This shim adapts the CLI's
+ * `callMcpEndpoint` transport into `ToolDeps` and threads the scope id
+ * (productId or teamId) through `deps.context` so the CLI can run AI
+ * sync against either a product or a team.
  */
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-/**
- * Create an in-process MCP server with checklist management tools.
- */
-export function createChecklistsMcpServer(productId) {
-    return createSdkMcpServer({
-        name: 'edsger-checklists',
-        version: '1.0.0',
-        tools: [
-            // ── Query tools ─────────────────────────────────────────────
-            tool('list_checklists', 'List all product-level checklists. Optionally filter by role or phase. Returns checklists with their items.', {
-                role: z
-                    .string()
-                    .optional()
-                    .describe('Filter by role: product_manager, developer, qa_engineer, technical_lead, ux_designer, devops_engineer, security_engineer'),
-                phase: z
-                    .string()
-                    .optional()
-                    .describe('Filter by phase (e.g., code_implementation, code_review, technical_design)'),
-            }, async (args) => {
-                const params = { product_id: productId };
-                if (args.role) {
-                    params.role = args.role;
-                }
-                if (args.phase) {
-                    params.phase = args.phase;
-                }
-                const result = await callMcpEndpoint('checklists/list', params);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            // ── Checklist CRUD ──────────────────────────────────────────
-            tool('create_checklist', 'Create a new product-level checklist. A checklist belongs to a role and applies to one or more phases. You can include items inline.', {
-                name: z.string().describe('Checklist name'),
-                description: z.string().optional().describe('Checklist description'),
-                role: z
-                    .string()
-                    .describe('Role: product_manager, developer, qa_engineer, technical_lead, ux_designer, devops_engineer, security_engineer'),
-                phases: z
-                    .array(z.string())
-                    .describe('Array of phases this checklist applies to (e.g., ["code_implementation", "code_review"])'),
-                sort_order: z
-                    .number()
-                    .optional()
-                    .describe('Display order (0-based). Assign incrementing values when creating multiple checklists.'),
-                items: z
-                    .array(z.object({
-                    title: z.string().describe('Item title'),
-                    description: z.string().optional().describe('Item description'),
-                    item_type: z
-                        .enum(['boolean', 'text', 'number', 'select'])
-                        .optional()
-                        .describe('Item type (default: boolean)'),
-                    is_required: z
-                        .boolean()
-                        .optional()
-                        .describe('Whether this item is required (default: true)'),
-                }))
-                    .optional()
-                    .describe('Items to create with the checklist'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('checklists/create', {
-                    product_id: productId,
-                    name: args.name,
-                    description: args.description || null,
-                    role: args.role,
-                    phases: args.phases,
-                    is_active: true,
-                    sort_order: args.sort_order ?? 0,
-                    items: args.items,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('update_checklist', 'Update an existing checklist. Only provide fields you want to change.', {
-                checklist_id: z.string().describe('Checklist ID to update'),
-                name: z.string().optional().describe('New name'),
-                description: z.string().optional().describe('New description'),
-                role: z.string().optional().describe('New role'),
-                phases: z.array(z.string()).optional().describe('New phases array'),
-                is_active: z
-                    .boolean()
-                    .optional()
-                    .describe('Whether the checklist is active'),
-            }, async (args) => {
-                const params = {
-                    checklist_id: args.checklist_id,
-                };
-                if (args.name !== undefined) {
-                    params.name = args.name;
-                }
-                if (args.description !== undefined) {
-                    params.description = args.description;
-                }
-                if (args.role !== undefined) {
-                    params.role = args.role;
-                }
-                if (args.phases !== undefined) {
-                    params.phases = args.phases;
-                }
-                if (args.is_active !== undefined) {
-                    params.is_active = args.is_active;
-                }
-                const result = await callMcpEndpoint('checklists/update', params);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('delete_checklist', 'Delete a checklist and all its items. Use with caution.', {
-                checklist_id: z.string().describe('Checklist ID to delete'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('checklists/delete', {
-                    checklist_id: args.checklist_id,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            // ── Checklist Items CRUD ────────────────────────────────────
-            tool('create_checklist_items', 'Add one or more items to an existing checklist.', {
-                checklist_id: z.string().describe('Checklist ID to add items to'),
-                items: z.array(z.object({
-                    title: z.string().describe('Item title'),
-                    description: z.string().optional().describe('Item description'),
-                    item_type: z
-                        .enum(['boolean', 'text', 'number', 'select'])
-                        .optional()
-                        .describe('Item type (default: boolean)'),
-                    is_required: z
-                        .boolean()
-                        .optional()
-                        .describe('Whether this item is required (default: true)'),
-                    sort_order: z.number().optional().describe('Sort order'),
-                    config: z
-                        .record(z.string(), z.unknown())
-                        .optional()
-                        .describe('Additional config (e.g., options for select type)'),
-                })),
-            }, async (args) => {
-                const result = await callMcpEndpoint('checklist_items/create', {
-                    checklist_id: args.checklist_id,
-                    items: args.items,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('update_checklist_item', 'Update an existing checklist item. Only provide fields you want to change.', {
-                item_id: z.string().describe('Item ID to update'),
-                title: z.string().optional().describe('New title'),
-                description: z.string().optional().describe('New description'),
-                item_type: z
-                    .enum(['boolean', 'text', 'number', 'select'])
-                    .optional()
-                    .describe('New item type'),
-                is_required: z
-                    .boolean()
-                    .optional()
-                    .describe('Whether this item is required'),
-                sort_order: z.number().optional().describe('New sort order'),
-                config: z
-                    .record(z.string(), z.unknown())
-                    .optional()
-                    .describe('New config'),
-            }, async (args) => {
-                const params = { item_id: args.item_id };
-                if (args.title !== undefined) {
-                    params.title = args.title;
-                }
-                if (args.description !== undefined) {
-                    params.description = args.description;
-                }
-                if (args.item_type !== undefined) {
-                    params.item_type = args.item_type;
-                }
-                if (args.is_required !== undefined) {
-                    params.is_required = args.is_required;
-                }
-                if (args.sort_order !== undefined) {
-                    params.sort_order = args.sort_order;
-                }
-                if (args.config !== undefined) {
-                    params.config = args.config;
-                }
-                const result = await callMcpEndpoint('checklist_items/update', params);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('delete_checklist_item', 'Delete a single checklist item.', {
-                item_id: z.string().describe('Item ID to delete'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('checklist_items/delete', {
-                    item_id: args.item_id,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-        ],
-    });
+import { createChecklistsMcpServer as createChecklistsMcpServerCore } from 'edsger-tools';
+import { getToolDeps } from '../../tools/bootstrap.js';
+export function createChecklistsMcpServer(scope) {
+    // Backwards compat: if a bare string is passed, treat it as productId.
+    const ctx = typeof scope === 'string'
+        ? { productId: scope }
+        : scope.kind === 'product'
+            ? { productId: scope.productId }
+            : { teamId: scope.teamId };
+    return createChecklistsMcpServerCore(getToolDeps(false, ctx));
 }

package/dist/commands/financing-deck/index.d.ts

@@ -0,0 +1,8 @@
+import { type CliOptions } from '../../types/index.js';
+/**
+ * Run AI-powered financing pitch deck draft for a product.
+ * Reads the founder's self-reported financial data + product issues +
+ * user feedback, then writes an 11-slide pitch deck to
+ * financing_ai_analyses for the desktop / web UI to render.
+ */
+export declare const runFinancingDeck: (options: CliOptions) => Promise<void>;

package/dist/commands/financing-deck/index.js

@@ -0,0 +1,66 @@
+import { generateFinancingDeck, } from '../../phases/financing-deck/index.js';
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+import { validateConfiguration } from '../../utils/validation.js';
+const VALID_STAGES = [
+    'pre_seed',
+    'seed',
+    'series_a',
+    'series_b',
+    'series_c',
+    'growth',
+];
+function isFinancingStage(value) {
+    return VALID_STAGES.includes(value);
+}
+/**
+ * Run AI-powered financing pitch deck draft for a product.
+ * Reads the founder's self-reported financial data + product issues +
+ * user feedback, then writes an 11-slide pitch deck to
+ * financing_ai_analyses for the desktop / web UI to render.
+ */
+export const runFinancingDeck = async (options) => {
+    const productId = options.financingDeck;
+    if (!productId) {
+        throw new Error('Product ID is required for financing-deck');
+    }
+    const targetStage = options.financingTargetStage;
+    if (!targetStage) {
+        throw new Error('Target stage is required (--target-stage). One of: pre_seed, seed, series_a, series_b, series_c, growth.');
+    }
+    if (!isFinancingStage(targetStage)) {
+        throw new Error(`Invalid target stage "${targetStage}". Expected one of: ${VALID_STAGES.join(', ')}`);
+    }
+    // validateConfiguration is required before any phase runs (parity with
+    // other commands).
+    validateConfiguration(options);
+    await registerSession({ command: 'financing-deck', productId });
+    logInfo(`Starting financing deck draft for product: ${productId} (target ${targetStage})`);
+    try {
+        const result = await generateFinancingDeck({
+            productId,
+            targetStage,
+            verbose: options.verbose,
+        });
+        if (result.status === 'success') {
+            logSuccess('Financing deck draft completed.');
+            logInfo(`  Slides: ${result.slideCount}`);
+            logInfo(`  Red flags: ${result.redFlagCount}`);
+            if (result.analysisId) {
+                logInfo(`  Saved analysis id: ${result.analysisId}`);
+            }
+            logInfo('\nView the draft in the Financing tab of your product dashboard.');
+        }
+        else {
+            logError(`Financing deck failed: ${result.summary}`);
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        logError(`Financing deck failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+    finally {
+        await deregisterSession();
+    }
+};

package/dist/commands/find-architecture/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CLI command: edsger find-architecture <productId>
+ * Audits the product's repository for architectural concerns (layering,
+ * coupling, cycles, missing/duplicated abstractions, responsibility creep)
+ * and files each new finding as an issue.
+ */
+export interface FindArchitectureCliOptions {
+    full?: boolean;
+    branch?: string;
+    maxFiles?: number;
+    verbose?: boolean;
+}
+export declare function runFindArchitecture(productId: string, options: FindArchitectureCliOptions): Promise<void>;

package/dist/commands/find-architecture/index.js

@@ -0,0 +1,41 @@
+/**
+ * CLI command: edsger find-architecture <productId>
+ * Audits the product's repository for architectural concerns (layering,
+ * coupling, cycles, missing/duplicated abstractions, responsibility creep)
+ * and files each new finding as an issue.
+ */
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { scanForArchitecture } from '../../phases/find-architecture/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runFindArchitecture(productId, options) {
+    const { full, branch, maxFiles, verbose } = options;
+    logInfo(`Starting architecture scan for product ${productId}`);
+    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    if (!githubConfig.configured ||
+        !githubConfig.token ||
+        !githubConfig.owner ||
+        !githubConfig.repo) {
+        logError(`GitHub not configured for product ${productId}: ${githubConfig.message || 'No installation found'}`);
+        process.exit(1);
+    }
+    const result = await scanForArchitecture({
+        productId,
+        githubToken: githubConfig.token,
+        owner: githubConfig.owner,
+        repo: githubConfig.repo,
+        full,
+        branch,
+        maxFiles,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(result.message);
+        if (result.summary) {
+            logInfo(result.summary);
+        }
+    }
+    else {
+        logError(result.message);
+        process.exit(1);
+    }
+}

package/dist/commands/issue-analysis/index.d.ts

@@ -0,0 +1,5 @@
+export interface IssueAnalysisCliOptions {
+    issueId: string;
+    verbose?: boolean;
+}
+export declare const runIssueAnalysisCommand: (options: IssueAnalysisCliOptions) => Promise<void>;

package/dist/commands/issue-analysis/index.js

@@ -0,0 +1,9 @@
+import { analyseIssue } from '../../phases/issue-analysis/index.js';
+import { runIssuePhaseCli } from '../../utils/issue-phase-cli.js';
+export const runIssueAnalysisCommand = (options) => runIssuePhaseCli({
+    command: 'issue-analysis',
+    description: 'Issue analysis',
+    issueId: options.issueId,
+    verbose: options.verbose,
+    execute: analyseIssue,
+});

package/dist/commands/sync-github-issues/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CLI command: `edsger sync-github-issues <productId>`
+ *
+ * Mirrors the connected GitHub repo's issues into the product's local issues
+ * list. New issues are inserted, updated descriptions flow through, and
+ * issues that disappeared remotely are flagged source_state='deleted'.
+ */
+export interface SyncGithubIssuesCliOptions {
+    verbose?: boolean;
+}
+export declare function runSyncGithubIssues(productId: string, options?: SyncGithubIssuesCliOptions): Promise<void>;

package/dist/commands/sync-github-issues/index.js

@@ -0,0 +1,42 @@
+/**
+ * CLI command: `edsger sync-github-issues <productId>`
+ *
+ * Mirrors the connected GitHub repo's issues into the product's local issues
+ * list. New issues are inserted, updated descriptions flow through, and
+ * issues that disappeared remotely are flagged source_state='deleted'.
+ */
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { syncGithubIssues } from '../../phases/sync-github-issues/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runSyncGithubIssues(productId, options = {}) {
+    const { verbose } = options;
+    logInfo(`Starting GitHub issue sync for product ${productId}`);
+    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    if (!githubConfig.configured ||
+        !githubConfig.token ||
+        !githubConfig.owner ||
+        !githubConfig.repo) {
+        logError(`GitHub not configured for product ${productId}: ${githubConfig.message || 'No installation found'}`);
+        process.exit(1);
+    }
+    const result = await syncGithubIssues({
+        productId,
+        githubToken: githubConfig.token,
+        owner: githubConfig.owner,
+        repo: githubConfig.repo,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(`GitHub sync completed: ${result.message}`);
+        if (result.repository) {
+            logInfo(`Repository: ${result.repository}`);
+        }
+        if (result.fetchedCount !== undefined) {
+            logInfo(`Fetched ${result.fetchedCount} · created ${result.createdCount ?? 0} · updated ${result.updatedCount ?? 0} · refreshed ${result.refreshedCount ?? 0} · deleted ${result.deletedCount ?? 0}`);
+        }
+    }
+    else {
+        logError(`GitHub sync failed: ${result.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/sync-sentry-issues/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CLI command: `edsger sync-sentry-issues <productId>`
+ *
+ * Reads Sentry credentials from process.env (populated by `edsger config
+ * set` via ~/.edsger/env.json or by real environment variables). For an
+ * MVP we intentionally don't put per-product Sentry config in the
+ * database — the auth token is user-scoped, and org/project rarely
+ * change. If the friction shows up, follow up by adding columns on the
+ * products table and a settings UI.
+ */
+export interface SyncSentryIssuesCliOptions {
+    verbose?: boolean;
+}
+export declare function runSyncSentryIssues(productId: string, options?: SyncSentryIssuesCliOptions): Promise<void>;