edsger 0.76.0 → 0.78.0

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

@@ -1,47 +0,0 @@
-import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
-import { logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-/**
- * Get issue details by ID
- */
-export async function getIssue(issueId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching issue details for: ${issueId}`);
-    }
-    if (hasSupabaseSession()) {
-        try {
-            const { data, error } = await getSupabase()
-                .from('issues')
-                .select('*')
-                .eq('id', issueId)
-                .maybeSingle();
-            if (error) {
-                throw new Error(error.message);
-            }
-            if (!data) {
-                throw new Error(`Issue not found: ${issueId}`);
-            }
-            return data;
-        }
-        catch (sdkErr) {
-            // Surface "not found" immediately so callers don't double-fetch via
-            // MCP for an issue that genuinely doesn't exist.
-            if (sdkErr instanceof Error &&
-                sdkErr.message === `Issue not found: ${issueId}`) {
-                throw sdkErr;
-            }
-            // Other errors fall through to MCP
-        }
-    }
-    const result = (await callMcpEndpoint('issues/get', {
-        issue_id: issueId,
-    }));
-    if (!result.issues || result.issues.length === 0) {
-        throw new Error(`Issue not found: ${issueId}`);
-    }
-    const issue = result.issues[0];
-    if (!issue || typeof issue !== 'object') {
-        throw new Error(`Invalid issue data returned for: ${issueId}`);
-    }
-    return issue;
-}

package/dist/api/issues/index.d.ts

@@ -1,8 +0,0 @@
-export * from './batch-operations.js';
-export * from './get-issue.js';
-export * from './issue-utils.js';
-export * from './status-updater.js';
-export * from './test-cases.js';
-export * from './update-issue.js';
-export * from './user-stories.js';
-export * from '../../types/issues.js';

package/dist/api/issues/index.js

@@ -1,10 +0,0 @@
-// Re-export all issue-related functions
-export * from './batch-operations.js';
-export * from './get-issue.js';
-export * from './issue-utils.js';
-export * from './status-updater.js';
-export * from './test-cases.js';
-export * from './update-issue.js';
-export * from './user-stories.js';
-// Re-export types
-export * from '../../types/issues.js';

package/dist/api/issues/issue-utils.d.ts

@@ -1,25 +0,0 @@
-import { type IssueInfo } from '../../types/issues.js';
-/**
- * Claim the next available ready_for_ai issue for processing.
- * Uses database-level locking (FOR UPDATE SKIP LOCKED) inside the RPC to
- * prevent race conditions between multiple workers.
- *
- * @param productId - Optional product ID to scope the claim. When omitted,
- *                    claims the next ready issue assigned to this worker
- *                    across any product (cross-product agent mode).
- * @param verbose - Whether to log verbose output
- * @returns The claimed issue or null if no issues available
- */
-export declare function claimNextIssue(productId?: string, verbose?: boolean): Promise<IssueInfo | null>;
-/**
- * Filter issues by status
- */
-export declare function filterIssuesByStatus(issues: IssueInfo[], status: string): IssueInfo[];
-/**
- * Sort issues by updated_at (oldest first for processing)
- */
-export declare function sortIssuesByUpdatedAt(issues: IssueInfo[]): IssueInfo[];
-/**
- * Get issues with ready_for_ai status for a product
- */
-export declare function getReadyForAIIssues(productId: string, verbose?: boolean): Promise<IssueInfo[]>;

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

@@ -1,133 +0,0 @@
-import { getUserId } from '../../auth/auth-store.js';
-import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-/**
- * Claim the next available ready_for_ai issue for processing.
- * Uses database-level locking (FOR UPDATE SKIP LOCKED) inside the RPC to
- * prevent race conditions between multiple workers.
- *
- * @param productId - Optional product ID to scope the claim. When omitted,
- *                    claims the next ready issue assigned to this worker
- *                    across any product (cross-product agent mode).
- * @param verbose - Whether to log verbose output
- * @returns The claimed issue or null if no issues available
- */
-export async function claimNextIssue(productId, verbose) {
-    if (verbose) {
-        logInfo(productId
-            ? `Attempting to claim next ready_for_ai issue for product: ${productId}`
-            : 'Attempting to claim next ready_for_ai issue across all products');
-    }
-    // Direct-SDK path: call the existing claim_next_ready_issue RPC. The RPC is
-    // SECURITY INVOKER and gates access by `developer_id = p_worker_id`, so the
-    // user JWT is honoured naturally.
-    const userId = getUserId();
-    if (hasSupabaseSession() && userId) {
-        try {
-            const { data, error } = await getSupabase().rpc('claim_next_ready_issue', {
-                p_worker_id: userId,
-                p_product_id: productId ?? null,
-            });
-            if (error) {
-                throw new Error(error.message);
-            }
-            const row = Array.isArray(data) ? data[0] : data;
-            if (!row) {
-                if (verbose) {
-                    logInfo('No issues available for processing');
-                }
-                return null;
-            }
-            // RPC returns rows with `issue_*` prefixed column names — unwrap to
-            // the IssueInfo shape callers already consume.
-            const r = row;
-            const issue = {
-                id: r.issue_id,
-                name: r.issue_name,
-                description: r.issue_description,
-                technical_design: r.issue_technical_design,
-                status: r.issue_status,
-                execution_mode: r.issue_execution_mode,
-                workflow: r.issue_workflow,
-                product_id: r.issue_product_id,
-                created_at: r.issue_created_at,
-                updated_at: r.issue_updated_at,
-                autonomous_hours: r.issue_autonomous_hours,
-                execution_plan: r.issue_execution_plan,
-            };
-            if (verbose) {
-                logInfo(`✅ Claimed issue: ${issue.name} (${issue.id})`);
-            }
-            return issue;
-        }
-        catch (sdkError) {
-            if (verbose) {
-                logError(`Direct issues/claim failed, falling back to MCP: ${sdkError instanceof Error ? sdkError.message : String(sdkError)}`);
-            }
-            // Fall through to MCP path
-        }
-    }
-    try {
-        const result = (await callMcpEndpoint('issues/claim', productId ? { product_id: productId } : {}));
-        if (result.issue) {
-            if (verbose) {
-                logInfo(`✅ Claimed issue: ${result.issue.name} (${result.issue.id})`);
-            }
-            return result.issue;
-        }
-        if (verbose) {
-            logInfo('No issues available for processing');
-        }
-        return null;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to claim issue: ${errorMessage}`);
-        throw error;
-    }
-}
-/**
- * Filter issues by status
- */
-export function filterIssuesByStatus(issues, status) {
-    return issues.filter((issue) => issue.status === status);
-}
-/**
- * Sort issues by updated_at (oldest first for processing)
- */
-export function sortIssuesByUpdatedAt(issues) {
-    return [...issues].sort((a, b) => {
-        const dateA = new Date(a.updated_at || 0).getTime();
-        const dateB = new Date(b.updated_at || 0).getTime();
-        return dateA - dateB;
-    });
-}
-/**
- * Get issues with ready_for_ai status for a product
- */
-export async function getReadyForAIIssues(productId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching ready_for_ai issues for product: ${productId}`);
-    }
-    try {
-        const result = (await callMcpEndpoint('issues/list', {
-            product_id: productId,
-            status: 'ready_for_ai',
-        }));
-        const issues = result.issues || [];
-        const sortedIssues = sortIssuesByUpdatedAt(issues);
-        if (verbose) {
-            logInfo(`✅ Found ${sortedIssues.length} ready_for_ai issues (oldest first)`);
-            sortedIssues.forEach((issue, index) => {
-                logInfo(`   ${index + 1}. ${issue.name} (updated: ${issue.updated_at})`);
-            });
-        }
-        return sortedIssues;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch ready_for_ai issues: ${errorMessage}`);
-        throw error;
-    }
-}

package/dist/api/issues/status-updater.d.ts

@@ -1,68 +0,0 @@
-/**
- * Worker-side phase progress writer.
- *
- * Under the 2D state model, phase progress lives in the workflow JSONB
- * column, not in issues.status. The lifecycle column changes only at:
- *   - claim time (ready_for_ai → assigned_to_ai, via claim_next_ready_issue)
- *   - first phase entry (assigned_to_ai → in_progress, automatic in enter_phase)
- *   - terminal completion (handled by orchestrator after all phases done)
- *
- * For each phase transition, we call the enter_phase RPC which atomically
- * closes any prior active phase and sets the target phase to running or
- * verifying. For non-active terminal states (completed/failed/skipped on a
- * specific phase, e.g. functional-testing setting itself to completed/failed
- * when the test result arrives), we call set_phase_state.
- *
- * Public exports:
- *   enterPhase(issueId, phase, state)            — primary write path
- *   setPhaseState(issueId, phase, state)         — terminal phase outcomes
- *   updateIssueStatus({issueId, status})         — direct lifecycle changes
- *   updateIssueStatusForPhase(issueId, phaseName, verbose)
- *     Stable signature for the orchestrator's 9 call sites; internally
- *     dispatches to enterPhase or setPhaseState based on the phase name.
- */
-import type { IssueStatus } from '../../types/index.js';
-interface StatusUpdateOptions {
-    readonly issueId: string;
-    readonly status: IssueStatus;
-    readonly verbose?: boolean;
-}
-/**
- * Forward-progression check for the legacy status enum. Retained for
- * lifecycle-only updates; phase progress no longer flows through here.
- */
-export declare function isForwardProgression(currentStatus: IssueStatus, newStatus: IssueStatus): boolean;
-/**
- * Direct lifecycle status update. Phase-driven callers should use
- * `enterPhase` / `setPhaseState` instead — this is for true lifecycle
- * writes only (e.g. shipping, archiving, failing terminally).
- */
-export declare function updateIssueStatus({ issueId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
-/**
- * Atomic phase transition. Closes any prior running/verifying phase and
- * marks the target phase as running or verifying. Bumps issues.status to
- * in_progress automatically when needed. Use this for active phase entry.
- *
- * Throws on RPC failure so callers can react (retry, escalate, abort).
- * Old boolean-returning behavior is preserved by updateIssueStatusForPhase
- * which wraps this call.
- */
-export declare function enterPhase(issueId: string, phase: string, state: 'running' | 'verifying', verbose?: boolean): Promise<void>;
-/**
- * Atomic phase state update — typically used to mark a phase as completed,
- * failed, or skipped without affecting other phases or issues.status.
- * For example, functional-testing/analyzer uses this to record
- * `functional_testing → completed` (testing passed) or
- * `functional_testing → failed` (testing failed).
- */
-export declare function setPhaseState(issueId: string, phase: string, state: 'pending' | 'running' | 'verifying' | 'completed' | 'failed' | 'skipped', verbose?: boolean): Promise<void>;
-/**
- * Update issue progress for a pipeline phase.
- *
- * Signature is preserved (issueId, phase, verbose) so all 9+ orchestrator
- * call sites continue to work without modification. The internal
- * implementation has been rewritten to call enter_phase, which writes to
- * workflow JSONB instead of issues.status.
- */
-export declare const updateIssueStatusForPhase: (issueId: string, phase: string, verbose?: boolean) => Promise<boolean>;
-export {};

package/dist/api/issues/status-updater.js

@@ -1,190 +0,0 @@
-/**
- * Worker-side phase progress writer.
- *
- * Under the 2D state model, phase progress lives in the workflow JSONB
- * column, not in issues.status. The lifecycle column changes only at:
- *   - claim time (ready_for_ai → assigned_to_ai, via claim_next_ready_issue)
- *   - first phase entry (assigned_to_ai → in_progress, automatic in enter_phase)
- *   - terminal completion (handled by orchestrator after all phases done)
- *
- * For each phase transition, we call the enter_phase RPC which atomically
- * closes any prior active phase and sets the target phase to running or
- * verifying. For non-active terminal states (completed/failed/skipped on a
- * specific phase, e.g. functional-testing setting itself to completed/failed
- * when the test result arrives), we call set_phase_state.
- *
- * Public exports:
- *   enterPhase(issueId, phase, state)            — primary write path
- *   setPhaseState(issueId, phase, state)         — terminal phase outcomes
- *   updateIssueStatus({issueId, status})         — direct lifecycle changes
- *   updateIssueStatusForPhase(issueId, phaseName, verbose)
- *     Stable signature for the orchestrator's 9 call sites; internally
- *     dispatches to enterPhase or setPhaseState based on the phase name.
- */
-import { STATUS_PROGRESSION_ORDER } from '../../config/issue-status.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-import { getIssue } from './get-issue.js';
-const PHASE_NAME_TO_WORKFLOW = {
-    // Active phase transitions (call enter_phase)
-    'issue-analysis': { kind: 'enter', phase: 'issue_analysis', state: 'running' },
-    'issue-analysis-verification': { kind: 'enter', phase: 'issue_analysis', state: 'verifying' },
-    'user-stories-analysis': { kind: 'enter', phase: 'user_stories_analysis', state: 'running' },
-    'user-stories-analysis-verification': { kind: 'enter', phase: 'user_stories_analysis', state: 'verifying' },
-    'test-cases-analysis': { kind: 'enter', phase: 'test_cases_analysis', state: 'running' },
-    'test-cases-analysis-verification': { kind: 'enter', phase: 'test_cases_analysis', state: 'verifying' },
-    'technical-design': { kind: 'enter', phase: 'technical_design', state: 'running' },
-    'technical-design-verification': { kind: 'enter', phase: 'technical_design', state: 'verifying' },
-    'branch-planning': { kind: 'enter', phase: 'branch_planning', state: 'running' },
-    'branch-planning-verification': { kind: 'enter', phase: 'branch_planning', state: 'verifying' },
-    'code-implementation': { kind: 'enter', phase: 'code_implementation', state: 'running' },
-    'code-implementation-verification': { kind: 'enter', phase: 'code_implementation', state: 'verifying' },
-    'pr-splitting': { kind: 'enter', phase: 'pr_splitting', state: 'running' },
-    'pr-splitting-verification': { kind: 'enter', phase: 'pr_splitting', state: 'verifying' },
-    'pr-execution': { kind: 'enter', phase: 'pr_execution', state: 'running' },
-    'functional-testing': { kind: 'enter', phase: 'functional_testing', state: 'running' },
-    'code-review': { kind: 'enter', phase: 'code_review', state: 'running' },
-    'ready-for-review': { kind: 'enter', phase: 'code_review', state: 'verifying' },
-    'code-refine': { kind: 'enter', phase: 'code_refine', state: 'running' },
-    'code-refine-verification': { kind: 'enter', phase: 'code_refine', state: 'verifying' },
-    'bug-fixing': { kind: 'enter', phase: 'bug_fixing', state: 'running' },
-    // Terminal phase outcomes (call set_phase_state)
-    'testing-passed': { kind: 'terminal', phase: 'functional_testing', state: 'completed' },
-    'testing-failed': { kind: 'terminal', phase: 'functional_testing', state: 'failed' },
-    'testing-in-progress': { kind: 'enter', phase: 'functional_testing', state: 'running' },
-};
-/**
- * Forward-progression check for the legacy status enum. Retained for
- * lifecycle-only updates; phase progress no longer flows through here.
- */
-export function isForwardProgression(currentStatus, newStatus) {
-    if (newStatus === 'archived') {
-        return true;
-    }
-    if (currentStatus === 'archived') {
-        return newStatus === 'backlog';
-    }
-    const currentIndex = STATUS_PROGRESSION_ORDER.indexOf(currentStatus);
-    const newIndex = STATUS_PROGRESSION_ORDER.indexOf(newStatus);
-    return newIndex >= currentIndex;
-}
-/**
- * Direct lifecycle status update. Phase-driven callers should use
- * `enterPhase` / `setPhaseState` instead — this is for true lifecycle
- * writes only (e.g. shipping, archiving, failing terminally).
- */
-export async function updateIssueStatus({ issueId, status, verbose = false, }) {
-    try {
-        if (verbose) {
-            logInfo(`Updating issue ${issueId} status to: ${status}`);
-        }
-        let issue;
-        let currentStatus;
-        try {
-            issue = await getIssue(issueId, verbose);
-            currentStatus = issue.status;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logError(`Failed to get current issue status for ${issueId}: ${errorMessage}`);
-            if (verbose) {
-                logInfo('⚠️ Skipping status update due to inability to verify current status');
-            }
-            return false;
-        }
-        if (!isForwardProgression(currentStatus, status)) {
-            const message = `⚠️ Skipping status regression: ${currentStatus} → ${status}. Only forward progression allowed.`;
-            if (verbose) {
-                logInfo(message);
-            }
-            return false;
-        }
-        if (currentStatus === status) {
-            if (verbose) {
-                logInfo(`Status already at ${status}, no update needed`);
-            }
-            return true;
-        }
-        await callMcpEndpoint('issues/update', { issue_id: issueId, status });
-        if (verbose) {
-            logInfo(`✅ Issue status updated successfully from ${currentStatus} to: ${status}`);
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (verbose) {
-            logError(`Failed to update issue status: ${errorMessage}`);
-        }
-        return false;
-    }
-}
-/**
- * Atomic phase transition. Closes any prior running/verifying phase and
- * marks the target phase as running or verifying. Bumps issues.status to
- * in_progress automatically when needed. Use this for active phase entry.
- *
- * Throws on RPC failure so callers can react (retry, escalate, abort).
- * Old boolean-returning behavior is preserved by updateIssueStatusForPhase
- * which wraps this call.
- */
-export async function enterPhase(issueId, phase, state, verbose = false) {
-    await callMcpEndpoint('issues/enter_phase', {
-        issue_id: issueId,
-        phase,
-        state,
-    });
-    if (verbose) {
-        logInfo(`✅ entered phase ${phase} (${state})`);
-    }
-}
-/**
- * Atomic phase state update — typically used to mark a phase as completed,
- * failed, or skipped without affecting other phases or issues.status.
- * For example, functional-testing/analyzer uses this to record
- * `functional_testing → completed` (testing passed) or
- * `functional_testing → failed` (testing failed).
- */
-export async function setPhaseState(issueId, phase, state, verbose = false) {
-    await callMcpEndpoint('issues/set_phase_state', {
-        issue_id: issueId,
-        phase,
-        state,
-    });
-    if (verbose) {
-        logInfo(`✅ set phase ${phase} → ${state}`);
-    }
-}
-/**
- * Update issue progress for a pipeline phase.
- *
- * Signature is preserved (issueId, phase, verbose) so all 9+ orchestrator
- * call sites continue to work without modification. The internal
- * implementation has been rewritten to call enter_phase, which writes to
- * workflow JSONB instead of issues.status.
- */
-export const updateIssueStatusForPhase = async (issueId, phase, verbose) => {
-    const mapping = PHASE_NAME_TO_WORKFLOW[phase];
-    if (!mapping) {
-        if (verbose) {
-            logInfo(`⚠️ Unknown phase '${phase}' — skipping status update`);
-        }
-        return false;
-    }
-    try {
-        if (mapping.kind === 'enter') {
-            await enterPhase(issueId, mapping.phase, mapping.state, verbose);
-        }
-        else {
-            await setPhaseState(issueId, mapping.phase, mapping.state, verbose);
-        }
-        return true;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (verbose) {
-            logError(`Failed to ${mapping.kind === 'enter' ? 'enter' : 'set'} phase ${mapping.phase} (${mapping.state}): ${message}`);
-        }
-        return false;
-    }
-};

package/dist/api/issues/test-cases.d.ts

@@ -1,29 +0,0 @@
-import { type TestCase, type TestCaseStatus } from '../../types/issues.js';
-/**
- * Get test cases for an issue
- */
-export declare function getTestCases(issueId: string, verbose?: boolean): Promise<TestCase[]>;
-/**
- * Create a new test case for an issue
- */
-export declare function createTestCase(issueId: string, testCase: {
-    name: string;
-    description: string;
-    is_critical?: boolean;
-}, verbose?: boolean): Promise<boolean>;
-/**
- * Create multiple test cases for an issue
- */
-export declare function createTestCases(mcpServerUrl: string, mcpToken: string, issueId: string, testCases: {
-    name: string;
-    description: string;
-    is_critical?: boolean;
-}[], verbose?: boolean): Promise<boolean>;
-/**
- * Delete a test case
- */
-export declare function deleteTestCase(testCaseId: string, verbose?: boolean): Promise<boolean>;
-/**
- * Update test case status
- */
-export declare function updateTestCaseStatus(testCaseId: string, status: TestCaseStatus, verbose?: boolean): Promise<boolean>;