edsger 0.76.0 → 0.78.0

package/dist/phases/sync-sentry-issues/types.d.ts

@@ -1,46 +0,0 @@
-/**
- * Shared types for sync-sentry-issues. Kept narrow on purpose: only the
- * fields the sync logic actually reads. Sentry's full payload has dozens of
- * keys we don't care about.
- */
-export type SentryIssueStatus = 'unresolved' | 'resolved' | 'ignored' | string;
-/**
- * Subset of the Sentry API issue payload we consume. The real shape has
- * more fields; we type only what's used so the snapshot stored in
- * `source_data` doesn't grow unbounded coupling.
- */
-export interface SentryIssueLite {
-    /** Numeric Sentry issue ID, returned as a string. Stable across the org. */
-    id: string;
-    /** Human-readable short ID like "PUMP-O" — useful in titles. */
-    shortId?: string | null;
-    title: string;
-    /** Where the error originates, e.g. "module.function in path/to/file.py". */
-    culprit?: string | null;
-    /** error / warning / fatal / info / debug. */
-    level?: string | null;
-    /** unresolved / resolved / ignored — used for source_state. */
-    status: SentryIssueStatus;
-    /** Direct link back into the Sentry UI. */
-    permalink: string;
-    /** ISO timestamp of the most recent event for this issue. */
-    lastSeen: string;
-    /** ISO timestamp of the first event for this issue. */
-    firstSeen?: string | null;
-    /** Total event count, returned as a string by Sentry. */
-    count?: string | number | null;
-    userCount?: number | null;
-    isUnhandled?: boolean | null;
-    platform?: string | null;
-}
-export interface SentrySyncResult {
-    status: 'success' | 'error';
-    message: string;
-    /** "<org>/<project>" we synced from. */
-    source?: string;
-    fetchedCount?: number;
-    createdCount?: number;
-    updatedCount?: number;
-    refreshedCount?: number;
-    deletedCount?: number;
-}

package/dist/phases/sync-sentry-issues/types.js

@@ -1,6 +0,0 @@
-/**
- * Shared types for sync-sentry-issues. Kept narrow on purpose: only the
- * fields the sync logic actually reads. Sentry's full payload has dozens of
- * keys we don't care about.
- */
-export {};

package/dist/phases/sync-shared/mcp.d.ts

@@ -1,81 +0,0 @@
-/**
- * MCP helpers shared by all sync-* phases (sync-github-issues,
- * sync-sentry-issues, future sync-linear-issues, ...).
- *
- * Each helper is a thin typed wrapper over `callMcpEndpoint` so phases
- * don't repeat the param marshalling. The contract:
- *
- *   - `listIssuesBySource`           — pre-load existing rows for verbose logs
- *   - `upsertExternalIssuesBatch`    — batch INSERT/UPDATE in one round-trip;
- *                                      returns action counts (created/updated/refreshed)
- *   - `markExternalIssuesDeletedSince` — sweep stale rows after a sync run
- *                                        completes successfully
- */
-import { EXTERNAL_SOURCES, type ExternalSource } from '../../types/external-sources.js';
-export { EXTERNAL_SOURCES, type ExternalSource };
-export interface ExternalIssueRow {
-    id: string;
-    source_id: string;
-    source_state: string | null;
-    source_url: string | null;
-    source_updated_at: string | null;
-    source_synced_at: string | null;
-}
-export interface ExternalIssueInput {
-    /** External system identifier (string form, even when remote uses numbers). */
-    sourceId: string;
-    /** Issue title for the local `name` column. */
-    name: string;
-    /**
-     * Markdown body. `null` skips the description on UPDATE; on INSERT it
-     * becomes a NULL description. The server-side hash check additionally
-     * preserves user-edited descriptions even when this is non-null.
-     */
-    description: string | null;
-    sourceUrl: string | null;
-    /** open / closed / unresolved / resolved / ignored — vocabulary per source. */
-    sourceState: string | null;
-    /** ISO timestamp from the remote system; used as dirty-check cursor. */
-    sourceUpdatedAt: string | null;
-    /** Optional raw payload snapshot for `source_data` JSONB. */
-    sourceData?: unknown;
-    /** Status to assign on initial INSERT; ignored on UPDATE. Defaults to 'backlog'. */
-    initialStatus?: string;
-}
-export interface BatchUpsertResult {
-    created: number;
-    updated: number;
-    refreshed: number;
-}
-/**
- * Maximum batch size for `upsertExternalIssuesBatch`. Mirrors the server-side
- * cap. Phases that have more issues than this should split into multiple
- * batches and aggregate the counts (see `upsertInBatches` helper).
- */
-export declare const MAX_BATCH_SIZE = 200;
-export declare function listIssuesBySource(productId: string, source: ExternalSource): Promise<ExternalIssueRow[]>;
-export declare function upsertExternalIssuesBatch(productId: string, source: ExternalSource, inputs: ExternalIssueInput[]): Promise<BatchUpsertResult>;
-/**
- * Convenience wrapper that splits an arbitrary-length input into chunks of
- * MAX_BATCH_SIZE, runs them sequentially, aggregates counts, and reports
- * how many of the batches failed (so the caller can decide whether to
- * trigger the deletion sweep).
- *
- * Sequential rather than parallel: a single large GitHub repo doesn't get
- * rate-limited by Postgres, but parallel writes against the same product
- * could deadlock on the unique index.
- */
-export declare function upsertInBatches(productId: string, source: ExternalSource, inputs: ExternalIssueInput[], onBatchError?: (error: Error, batchIndex: number) => void): Promise<{
-    result: BatchUpsertResult;
-    failedBatches: number;
-}>;
-/**
- * Mark every (product, source) row whose source_synced_at is older than
- * the cutoff as deleted. The caller should pass the wall-clock time
- * recorded BEFORE the first upsert ran — anything we touched will be
- * younger than that, anything we didn't touch is gone remotely.
- *
- * IMPORTANT: only call this after every batch in the run succeeded.
- * Calling it after a partial failure would mark live issues as deleted.
- */
-export declare function markExternalIssuesDeletedSince(productId: string, source: ExternalSource, syncedSince: string): Promise<number>;

package/dist/phases/sync-shared/mcp.js

@@ -1,111 +0,0 @@
-/**
- * MCP helpers shared by all sync-* phases (sync-github-issues,
- * sync-sentry-issues, future sync-linear-issues, ...).
- *
- * Each helper is a thin typed wrapper over `callMcpEndpoint` so phases
- * don't repeat the param marshalling. The contract:
- *
- *   - `listIssuesBySource`           — pre-load existing rows for verbose logs
- *   - `upsertExternalIssuesBatch`    — batch INSERT/UPDATE in one round-trip;
- *                                      returns action counts (created/updated/refreshed)
- *   - `markExternalIssuesDeletedSince` — sweep stale rows after a sync run
- *                                        completes successfully
- */
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { EXTERNAL_SOURCES, } from '../../types/external-sources.js';
-export { EXTERNAL_SOURCES };
-/**
- * Maximum batch size for `upsertExternalIssuesBatch`. Mirrors the server-side
- * cap. Phases that have more issues than this should split into multiple
- * batches and aggregate the counts (see `upsertInBatches` helper).
- */
-export const MAX_BATCH_SIZE = 200;
-export async function listIssuesBySource(productId, source) {
-    const result = (await callMcpEndpoint('issues/list_by_source', {
-        product_id: productId,
-        source,
-    }));
-    return result.issues ?? [];
-}
-export async function upsertExternalIssuesBatch(productId, source, inputs) {
-    if (inputs.length === 0) {
-        return { created: 0, updated: 0, refreshed: 0 };
-    }
-    if (inputs.length > MAX_BATCH_SIZE) {
-        throw new Error(`Batch too large (${inputs.length} > ${MAX_BATCH_SIZE}); use upsertInBatches`);
-    }
-    const items = inputs.map((input) => {
-        const item = {
-            source_id: input.sourceId,
-            name: input.name,
-            description: input.description,
-            source_url: input.sourceUrl,
-            source_state: input.sourceState,
-            source_updated_at: input.sourceUpdatedAt,
-        };
-        if (input.sourceData !== undefined) {
-            item.source_data = input.sourceData;
-        }
-        if (input.initialStatus) {
-            item.initial_status = input.initialStatus;
-        }
-        return item;
-    });
-    const result = (await callMcpEndpoint('issues/upsert_external_batch', {
-        product_id: productId,
-        source,
-        items,
-    }));
-    return {
-        created: result.created ?? 0,
-        updated: result.updated ?? 0,
-        refreshed: result.refreshed ?? 0,
-    };
-}
-/**
- * Convenience wrapper that splits an arbitrary-length input into chunks of
- * MAX_BATCH_SIZE, runs them sequentially, aggregates counts, and reports
- * how many of the batches failed (so the caller can decide whether to
- * trigger the deletion sweep).
- *
- * Sequential rather than parallel: a single large GitHub repo doesn't get
- * rate-limited by Postgres, but parallel writes against the same product
- * could deadlock on the unique index.
- */
-export async function upsertInBatches(productId, source, inputs, onBatchError) {
-    const aggregate = { created: 0, updated: 0, refreshed: 0 };
-    let failedBatches = 0;
-    for (let i = 0; i < inputs.length; i += MAX_BATCH_SIZE) {
-        const slice = inputs.slice(i, i + MAX_BATCH_SIZE);
-        try {
-            const r = await upsertExternalIssuesBatch(productId, source, slice);
-            aggregate.created += r.created;
-            aggregate.updated += r.updated;
-            aggregate.refreshed += r.refreshed;
-        }
-        catch (error) {
-            failedBatches += 1;
-            if (onBatchError) {
-                onBatchError(error instanceof Error ? error : new Error(String(error)), Math.floor(i / MAX_BATCH_SIZE));
-            }
-        }
-    }
-    return { result: aggregate, failedBatches };
-}
-/**
- * Mark every (product, source) row whose source_synced_at is older than
- * the cutoff as deleted. The caller should pass the wall-clock time
- * recorded BEFORE the first upsert ran — anything we touched will be
- * younger than that, anything we didn't touch is gone remotely.
- *
- * IMPORTANT: only call this after every batch in the run succeeded.
- * Calling it after a partial failure would mark live issues as deleted.
- */
-export async function markExternalIssuesDeletedSince(productId, source, syncedSince) {
-    const result = (await callMcpEndpoint('issues/mark_deleted_for_source', {
-        product_id: productId,
-        source,
-        synced_since: syncedSince,
-    }));
-    return result.marked_deleted_count;
-}

package/dist/phases/task/agent.d.ts

@@ -1,10 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-export interface TaskResult {
-    success: boolean;
-    summary: string;
-}
-/**
- * Execute a task using Claude Agent SDK.
- * The agent has access to the codebase and can read/write files.
- */
-export declare function executeTask(taskPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<TaskResult>;

package/dist/phases/task/agent.js

@@ -1,83 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
-async function* prompt(taskPrompt) {
-    yield userMessage(taskPrompt);
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function processAssistantContent(content, verbose) {
-    let text = '';
-    for (const item of content) {
-        if (item.type === 'text') {
-            text += `${item.text}\n`;
-            logDebug(`${item.text}`, verbose);
-        }
-        else if (item.type === 'tool_use') {
-            logDebug(`${item.name}: ${item.input.description || 'Running...'}`, verbose);
-        }
-    }
-    return text;
-}
-/**
- * Execute a task using Claude Agent SDK.
- * The agent has access to the codebase and can read/write files.
- */
-export async function executeTask(taskPrompt, systemPrompt, config, verbose) {
-    let lastAssistantResponse = '';
-    try {
-        for await (const message of query({
-            prompt: prompt(taskPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
-            }
-            if (message.type === 'assistant' && message.message?.content) {
-                lastAssistantResponse += processAssistantContent(message.message.content, verbose);
-            }
-            if (message.type === 'result') {
-                if (message.subtype === 'success') {
-                    logInfo('Task completed successfully');
-                    return {
-                        success: true,
-                        summary: message.result || lastAssistantResponse || 'Task completed',
-                    };
-                }
-                logError(`Task incomplete: ${message.subtype}`);
-                return {
-                    success: false,
-                    summary: lastAssistantResponse ||
-                        `Task ended with status: ${message.subtype}`,
-                };
-            }
-        }
-        return {
-            success: !!lastAssistantResponse,
-            summary: lastAssistantResponse || 'No response received',
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Task execution failed: ${errorMessage}`);
-        return {
-            success: false,
-            summary: `Execution failed: ${errorMessage}`,
-        };
-    }
-}

package/dist/phases/task/context.d.ts

@@ -1,16 +0,0 @@
-import { type ProductInfo } from '../../api/products.js';
-import { type TaskInfo } from '../../api/tasks.js';
-export interface TaskContext {
-    product: ProductInfo;
-    task: TaskInfo;
-}
-/**
- * Fetch context for a product task:
- * - Product info (name, description)
- * - The task itself
- */
-export declare function fetchTaskContext(task: TaskInfo, verbose?: boolean): Promise<TaskContext>;
-/**
- * Format task context into a prompt string
- */
-export declare function formatTaskContext(context: TaskContext): string;

package/dist/phases/task/context.js

@@ -1,50 +0,0 @@
-import { getProduct } from '../../api/products.js';
-import { logError, logInfo } from '../../utils/logger.js';
-/**
- * Fetch context for a product task:
- * - Product info (name, description)
- * - The task itself
- */
-export async function fetchTaskContext(task, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching context for task: ${task.name}`);
-            logInfo(`  Product ID: ${task.product_id}`);
-        }
-        const product = await getProduct(task.product_id, verbose);
-        if (verbose) {
-            logInfo(`Task context fetched:`);
-            logInfo(`  Product: ${product.name}`);
-        }
-        return { product, task };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch task context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}
-/**
- * Format task context into a prompt string
- */
-export function formatTaskContext(context) {
-    const { product, task } = context;
-    return `# Task Context
-
-## Product
-- **Name**: ${product.name}
-- **Product ID**: ${product.id}
-- **Description**: ${product.description || 'No description'}
-
----
-
-## Current Task
-- **Task Name**: ${task.name}
-- **Task ID**: ${task.id}
-- **Priority**: ${task.priority} (1=low, 2=medium, 3=high, 4=urgent)
-- **Description**: ${task.description || 'No description provided'}
-
----
-
-**Your objective**: Complete the task described above within the context of this product.`;
-}

package/dist/phases/task/index.d.ts

@@ -1,17 +0,0 @@
-import { type TaskInfo } from '../../api/tasks.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type TaskResult } from './agent.js';
-export type { TaskResult };
-export interface TaskOptions {
-    task: TaskInfo;
-    verbose?: boolean;
-}
-/**
- * Execute a product task:
- * 1. Mark task as in_progress
- * 2. Fetch product context
- * 3. Build prompt with context + task description
- * 4. Run Claude agent to complete the task
- * 5. Mark task as completed or blocked
- */
-export declare function runTask(options: TaskOptions, config: EdsgerConfig): Promise<TaskResult>;

package/dist/phases/task/index.js

@@ -1,54 +0,0 @@
-import { updateTaskStatus } from '../../api/tasks.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { executeTask } from './agent.js';
-import { fetchTaskContext, formatTaskContext } from './context.js';
-import { createTaskPrompt, createTaskSystemPrompt } from './prompts.js';
-/**
- * Execute a product task:
- * 1. Mark task as in_progress
- * 2. Fetch product context
- * 3. Build prompt with context + task description
- * 4. Run Claude agent to complete the task
- * 5. Mark task as completed or blocked
- */
-export async function runTask(options, config) {
-    const { task, verbose } = options;
-    logInfo(`Starting task: ${task.name} (${task.id})`);
-    // Mark as in_progress
-    await updateTaskStatus(task.id, 'in_progress', verbose);
-    try {
-        // 1. Fetch context
-        if (verbose) {
-            logInfo('Fetching task context...');
-        }
-        const context = await fetchTaskContext(task, verbose);
-        // 2. Build prompts
-        const contextInfo = formatTaskContext(context);
-        const systemPrompt = await createTaskSystemPrompt();
-        const taskPrompt = createTaskPrompt(contextInfo);
-        if (verbose) {
-            logInfo('Starting AI agent for task...');
-        }
-        // 3. Execute
-        const result = await executeTask(taskPrompt, systemPrompt, config, verbose);
-        // 4. Update status
-        if (result.success) {
-            await updateTaskStatus(task.id, 'completed', verbose);
-            logInfo(`Task completed: ${task.name}`);
-        }
-        else {
-            await updateTaskStatus(task.id, 'blocked', verbose);
-            logError(`Task blocked: ${task.name} - ${result.summary}`);
-        }
-        return result;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Task failed: ${task.name} - ${errorMessage}`);
-        await updateTaskStatus(task.id, 'blocked', verbose);
-        return {
-            success: false,
-            summary: `Failed: ${errorMessage}`,
-        };
-    }
-}

package/dist/phases/task/prompts.d.ts

@@ -1,9 +0,0 @@
-/**
- * System prompt for product task execution.
- * The agent works on a specific task within a product's codebase.
- */
-export declare function createTaskSystemPrompt(projectDir?: string): Promise<string>;
-/**
- * Create the user prompt combining context and task instructions
- */
-export declare function createTaskPrompt(contextInfo: string): string;

package/dist/phases/task/prompts.js

@@ -1,21 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-/**
- * System prompt for product task execution.
- * The agent works on a specific task within a product's codebase.
- */
-export async function createTaskSystemPrompt(projectDir) {
-    const skill = await resolveSkill('phase/task', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/task');
-    }
-    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['task']}`;
-}
-/**
- * Create the user prompt combining context and task instructions
- */
-export function createTaskPrompt(contextInfo) {
-    return `${contextInfo}
-
-Please complete the task described above. Use the codebase tools available to you to implement the changes needed.`;
-}

package/dist/phases/technical-design/context.d.ts

@@ -1,12 +0,0 @@
-import { type ProductInfo } from '../../api/products.js';
-import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
-export interface TechnicalDesignContext {
-    issue: IssueInfo;
-    product: ProductInfo;
-    user_stories: UserStory[];
-    test_cases: TestCase[];
-}
-/**
- * Fetch all technical design context information via MCP endpoints
- */
-export declare function fetchTechnicalDesignContext(issueId: string, verbose?: boolean): Promise<TechnicalDesignContext>;

package/dist/phases/technical-design/context.js

@@ -1,39 +0,0 @@
-import { getIssue, getTestCases, getUserStories, } from '../../api/issues/index.js';
-import { getProduct } from '../../api/products.js';
-import { logError, logInfo } from '../../utils/logger.js';
-/**
- * Fetch all technical design context information via MCP endpoints
- */
-export async function fetchTechnicalDesignContext(issueId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching complete technical design context for issue: ${issueId}`);
-        }
-        // Fetch all required data in parallel for better performance
-        const [issue, userStories, testCases] = await Promise.all([
-            getIssue(issueId, verbose),
-            getUserStories(issueId, verbose),
-            getTestCases(issueId, verbose),
-        ]);
-        const product = await getProduct(issue.product_id, verbose);
-        if (verbose) {
-            logInfo(`✅ Technical design context fetched successfully:`);
-            logInfo(`   Issue: ${issue.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   User Stories: ${userStories.length}`);
-            logInfo(`   Test Cases: ${testCases.length} (${testCases.filter((tc) => tc.is_critical).length} critical)`);
-            logInfo(`   Existing Technical Design: ${issue.technical_design ? 'Yes' : 'No'}`);
-        }
-        return {
-            issue,
-            product,
-            user_stories: userStories,
-            test_cases: testCases,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch technical design context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}

package/dist/phases/technical-design/index.d.ts

@@ -1,21 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type ChecklistItemResult, type EdsgerConfig, type VerificationResult } from '../../types/index.js';
-export interface TechnicalDesignOptions {
-    issueId: string;
-    verbose?: boolean;
-    maxVerificationIterations?: number;
-}
-export interface TechnicalDesignResult {
-    issueId: string;
-    technicalDesign: string | null;
-    status: 'success' | 'error';
-    summary: string;
-    verificationResult?: VerificationResult;
-    iterations?: number;
-    savedViaHttp?: boolean;
-    data?: {
-        checklist_item_results?: ChecklistItemResult[];
-        [key: string]: unknown;
-    };
-}
-export declare const generateTechnicalDesign: (options: TechnicalDesignOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<TechnicalDesignResult>;