edsger 0.76.0 → 0.78.0

package/dist/commands/workflow/processor.d.ts

@@ -1,47 +0,0 @@
-/**
- * Main workflow processor for continuous issue development
- * Monitors for ready_for_ai issues and processes them through the complete pipeline
- * Uses functional programming principles
- */
-import { type EdsgerConfig } from '../../types/index.js';
-import { type WorkflowStats } from './core/state-manager.js';
-export interface WorkflowOptions {
-    readonly productId: string;
-    readonly mcpServerUrl: string;
-    readonly mcpToken: string;
-    readonly pollInterval?: number;
-    readonly maxRetries?: number;
-    readonly verbose?: boolean;
-}
-/**
- * Workflow processor using functional programming principles
- */
-export declare class WorkflowProcessor {
-    private readonly options;
-    private readonly config;
-    private isRunning;
-    private processedIssues;
-    private pollTimer?;
-    constructor(options: WorkflowOptions, config: EdsgerConfig);
-    /**
-     * Start the workflow processor
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the workflow processor
-     */
-    stop(): void;
-    /**
-     * Process the next available issue using atomic claim mechanism
-     * Uses database-level locking to prevent race conditions between workers
-     */
-    private processNextIssue;
-    /**
-     * Process a single issue through the complete pipeline using functional composition
-     */
-    private processIssue;
-    /**
-     * Get current processing statistics using pure function
-     */
-    getStats(): WorkflowStats;
-}

package/dist/commands/workflow/processor.js

@@ -1,149 +0,0 @@
-/**
- * Main workflow processor for continuous issue development
- * Monitors for ready_for_ai issues and processes them through the complete pipeline
- * Uses functional programming principles
- */
-import { claimNextIssue } from '../../api/issues/index.js';
-import { logInfo } from '../../utils/logger.js';
-import { evaluatePipelineResults } from './core/pipeline-evaluator.js';
-// Import core modules
-import { calculateStats, createCompletedState, createFailedState, createInitialState, createProcessingState, updateIssueState, } from './core/state-manager.js';
-import { logIssueError, logIssueFailed, logIssueSuccess, logNoIssuesFound, logPipelineResults, logPollingError, logProcessingStart, logProcessNextIssueError, logProcessorReady, logProcessorStart, logProcessorStop, logRetryInfo, logSkippingProcessing, } from './core/workflow-logger.js';
-import { runIssueWorkflow } from './issue-coordinator.js';
-/**
- * Workflow processor using functional programming principles
- */
-export class WorkflowProcessor {
-    options;
-    config;
-    isRunning = false;
-    processedIssues = createInitialState();
-    pollTimer;
-    constructor(options, config) {
-        this.options = {
-            pollInterval: 30000, // 30 seconds default
-            maxRetries: 3,
-            verbose: false, // default value
-            ...options,
-        };
-        this.config = config;
-    }
-    /**
-     * Start the workflow processor
-     */
-    async start() {
-        if (this.isRunning) {
-            logInfo('Workflow processor is already running');
-            return;
-        }
-        this.isRunning = true;
-        logProcessorStart(this.options.productId, this.options.pollInterval);
-        // Initial check
-        await this.processNextIssue();
-        // Set up polling for new issues
-        this.pollTimer = setInterval(() => {
-            this.processNextIssue().catch((error) => {
-                logPollingError(error);
-            });
-        }, this.options.pollInterval);
-        logProcessorReady();
-    }
-    /**
-     * Stop the workflow processor
-     */
-    stop() {
-        if (!this.isRunning) {
-            return;
-        }
-        this.isRunning = false;
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = undefined;
-        }
-        logProcessorStop();
-    }
-    /**
-     * Process the next available issue using atomic claim mechanism
-     * Uses database-level locking to prevent race conditions between workers
-     */
-    async processNextIssue() {
-        try {
-            // Skip issue fetching if there are any issues currently being processed
-            const stats = calculateStats(this.processedIssues, this.isRunning);
-            if (stats.processing > 0) {
-                if (this.options.verbose) {
-                    logSkippingProcessing(stats.processing);
-                }
-                return;
-            }
-            // Atomically claim the next available issue
-            // This uses FOR UPDATE SKIP LOCKED to prevent multiple workers from claiming the same issue
-            const claimedIssue = await claimNextIssue(this.options.productId, this.options.verbose);
-            if (!claimedIssue) {
-                if (this.options.verbose) {
-                    logNoIssuesFound();
-                }
-                return;
-            }
-            // Process the claimed issue
-            await this.processIssue(claimedIssue);
-        }
-        catch (error) {
-            logProcessNextIssueError(error);
-        }
-    }
-    /**
-     * Process a single issue through the complete pipeline using functional composition
-     */
-    async processIssue(issue) {
-        const issueId = issue.id;
-        // Check if this is a reprocess due to issue update
-        const existingState = this.processedIssues.get(issueId);
-        if (existingState &&
-            existingState.status === 'completed' &&
-            this.options.verbose) {
-            logInfo(`🔄 Reprocessing issue "${issue.name}" - detected status change`);
-            if (issue.updated_at) {
-                logInfo(`  Previous process: ${existingState.lastAttempt.toISOString()}`);
-                logInfo(`  Issue updated: ${issue.updated_at}`);
-            }
-        }
-        // Update state to processing using pure function
-        this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createProcessingState(issueId, currentState));
-        logProcessingStart(issue, this.options.verbose);
-        try {
-            // Run issue workflow using issue coordinator with execution mode support
-            const results = await runIssueWorkflow({
-                issueId,
-                verbose: this.options.verbose,
-            }, this.config);
-            // Evaluate results using pure function
-            const allSuccessful = evaluatePipelineResults(results);
-            if (allSuccessful) {
-                // Mark as completed using pure function
-                this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createCompletedState(issueId, currentState));
-                logIssueSuccess(issue.name);
-                logPipelineResults(results);
-            }
-            else {
-                // Mark as failed using pure function
-                this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
-                logIssueFailed(issue.name);
-                logPipelineResults(results);
-                const currentState = this.processedIssues.get(issueId);
-                logRetryInfo(issue.name, currentState?.retryCount ?? 0, this.options.maxRetries);
-            }
-        }
-        catch (error) {
-            // Mark as failed using pure function
-            this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
-            logIssueError(issue.name, error);
-        }
-    }
-    /**
-     * Get current processing statistics using pure function
-     */
-    getStats() {
-        return calculateStats(this.processedIssues, this.isRunning);
-    }
-}

package/dist/config/issue-status.d.ts

@@ -1,29 +0,0 @@
-/**
- * Issue lifecycle status configuration.
- *
- * Under the 2D model, issues.status carries 7 lifecycle values. Phase
- * progress lives in the workflow JSONB column instead.
- *
- * The map kebab-case→workflow used by the worker is in
- *   ../api/issues/status-updater.ts (PHASE_NAME_TO_WORKFLOW)
- * — this file only owns the lifecycle status enum + ordering used by
- * isForwardProgression().
- */
-import type { IssueStatus } from '../types/index.js';
-/**
- * Lifecycle progression order. Used by isForwardProgression() to reject
- * regressions — e.g. you can move backlog → ready_for_ai but not the
- * other way around.
- *
- * Special-cases (handled in isForwardProgression):
- *   - any status → archived: always allowed
- *   - archived → backlog: always allowed (unarchive)
- */
-export declare const STATUS_PROGRESSION_ORDER: readonly IssueStatus[];
-/**
- * Statuses a human can pick from a dropdown. AI-managed states
- * (assigned_to_ai, in_progress) are written by the worker and not
- * exposed for manual selection.
- */
-export declare const HUMAN_SELECTABLE_STATUSES: readonly IssueStatus[];
-export declare function isHumanSelectableStatus(status: IssueStatus): boolean;

package/dist/config/issue-status.js

@@ -1,44 +0,0 @@
-/**
- * Issue lifecycle status configuration.
- *
- * Under the 2D model, issues.status carries 7 lifecycle values. Phase
- * progress lives in the workflow JSONB column instead.
- *
- * The map kebab-case→workflow used by the worker is in
- *   ../api/issues/status-updater.ts (PHASE_NAME_TO_WORKFLOW)
- * — this file only owns the lifecycle status enum + ordering used by
- * isForwardProgression().
- */
-/**
- * Lifecycle progression order. Used by isForwardProgression() to reject
- * regressions — e.g. you can move backlog → ready_for_ai but not the
- * other way around.
- *
- * Special-cases (handled in isForwardProgression):
- *   - any status → archived: always allowed
- *   - archived → backlog: always allowed (unarchive)
- */
-export const STATUS_PROGRESSION_ORDER = [
-    'backlog',
-    'ready_for_ai',
-    'assigned_to_ai',
-    'in_progress',
-    'shipped',
-    'failed',
-    'archived',
-];
-/**
- * Statuses a human can pick from a dropdown. AI-managed states
- * (assigned_to_ai, in_progress) are written by the worker and not
- * exposed for manual selection.
- */
-export const HUMAN_SELECTABLE_STATUSES = [
-    'backlog',
-    'ready_for_ai',
-    'shipped',
-    'archived',
-    'failed',
-];
-export function isHumanSelectableStatus(status) {
-    return HUMAN_SELECTABLE_STATUSES.includes(status);
-}

package/dist/config.d.ts

@@ -1,3 +0,0 @@
-import { type EdsgerConfig } from './types/index.js';
-export declare const loadConfig: (configPath?: string) => EdsgerConfig;
-export declare const validateConfig: (config: EdsgerConfig) => string[];

package/dist/config.js

@@ -1,79 +0,0 @@
-import { cosmiconfigSync } from 'cosmiconfig';
-const DEFAULT_CONFIG = {
-    patterns: [
-        '**/*.js',
-        '**/*.jsx',
-        '**/*.ts',
-        '**/*.tsx',
-        '**/*.vue',
-        '**/*.py',
-        '**/*.go',
-        '**/*.rs',
-        '**/*.java',
-        '**/*.cpp',
-        '**/*.c',
-        '**/*.h',
-    ],
-    exclude: [
-        '**/node_modules/**',
-        '**/dist/**',
-        '**/build/**',
-        '**/*.test.js',
-        '**/*.spec.js',
-        '**/*.test.ts',
-        '**/*.spec.ts',
-        '**/__tests__/**',
-        '**/*.min.js',
-        '**/*.bundle.js',
-    ],
-    severity: 'error',
-    maxFiles: 50,
-    claude: {
-        timeout: 120000,
-    },
-    workflow: {
-        maxConcurrency: 3,
-        pollInterval: 30_000,
-        maxRetries: 3,
-        retryCooldown: 5 * 60 * 1000,
-        workerTimeout: 30 * 60 * 1000,
-        maxVerificationIterations: 10,
-    },
-};
-export const loadConfig = (configPath) => {
-    const explorer = cosmiconfigSync('edsger');
-    const result = configPath ? explorer.load(configPath) : explorer.search();
-    const userConfig = result?.config || {};
-    return {
-        ...DEFAULT_CONFIG,
-        ...userConfig,
-        claude: {
-            ...DEFAULT_CONFIG.claude,
-            ...(userConfig.claude || {}),
-        },
-        workflow: {
-            ...DEFAULT_CONFIG.workflow,
-            ...(userConfig.workflow || {}),
-        },
-    };
-};
-export const validateConfig = (config) => {
-    const errors = [];
-    if (!Array.isArray(config.patterns) || config.patterns.length === 0) {
-        errors.push('patterns must be a non-empty array');
-    }
-    if (!Array.isArray(config.exclude)) {
-        errors.push('exclude must be an array');
-    }
-    if (!['error', 'warning'].includes(config.severity)) {
-        errors.push('severity must be "error" or "warning"');
-    }
-    if (typeof config.maxFiles !== 'number' || config.maxFiles <= 0) {
-        errors.push('maxFiles must be a positive number');
-    }
-    if (config.claude.timeout &&
-        (typeof config.claude.timeout !== 'number' || config.claude.timeout <= 0)) {
-        errors.push('claude.timeout must be a positive number');
-    }
-    return errors;
-};

package/dist/constants.d.ts

@@ -1,10 +0,0 @@
-/**
- * Default Claude model used across all phases and commands.
- * Change this single value to switch the model for the entire package.
- */
-export declare const DEFAULT_MODEL = "opus";
-export declare function getVersion(): string;
-/**
- * Reset the cached version (used after auto-update)
- */
-export declare function resetVersionCache(): void;

package/dist/constants.js

@@ -1,36 +0,0 @@
-/**
- * Default Claude model used across all phases and commands.
- * Change this single value to switch the model for the entire package.
- */
-export const DEFAULT_MODEL = 'opus';
-/**
- * Get the current package version from package.json
- * Cached after first read
- */
-import { readFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-let _cachedVersion = null;
-export function getVersion() {
-    if (_cachedVersion) {
-        return _cachedVersion;
-    }
-    try {
-        // eslint-disable-next-line @typescript-eslint/naming-convention -- ESM __filename/__dirname polyfill
-        const __filename = fileURLToPath(import.meta.url);
-        // eslint-disable-next-line @typescript-eslint/naming-convention -- ESM __filename/__dirname polyfill
-        const __dirname = dirname(__filename);
-        const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
-        _cachedVersion = pkg.version;
-        return _cachedVersion;
-    }
-    catch {
-        return 'unknown';
-    }
-}
-/**
- * Reset the cached version (used after auto-update)
- */
-export function resetVersionCache() {
-    _cachedVersion = null;
-}

package/dist/errors/index.d.ts

@@ -1,68 +0,0 @@
-/**
- * Edsger error classification system.
- *
- * All errors extend EdsgerError so callers can:
- *   catch (error) { if (error instanceof EdsgerError) { ... } }
- *
- * Each subclass carries a `code` discriminant for structured handling,
- * plus optional context fields relevant to that error category.
- */
-export type EdsgerErrorCode = 'API_ERROR' | 'GITHUB_ERROR' | 'AUTH_ERROR' | 'CONFIG_ERROR' | 'PHASE_ERROR' | 'LLM_PARSE_ERROR' | 'WORKER_TIMEOUT' | 'WORKER_CRASH' | 'VALIDATION_ERROR' | 'HOOK_ERROR';
-export declare class EdsgerError extends Error {
-    readonly code: EdsgerErrorCode;
-    constructor(code: EdsgerErrorCode, message: string, options?: ErrorOptions);
-    /** Wrap an unknown thrown value into an EdsgerError, preserving cause chain. */
-    static from(code: EdsgerErrorCode, context: string, thrown: unknown): EdsgerError;
-}
-export declare class ApiError extends EdsgerError {
-    readonly endpoint: string;
-    readonly statusCode?: number;
-    constructor(endpoint: string, message: string, statusCode?: number, options?: ErrorOptions);
-}
-export declare class GitHubError extends EdsgerError {
-    readonly owner?: string;
-    readonly repo?: string;
-    readonly statusCode?: number;
-    constructor(message: string, details?: {
-        owner?: string;
-        repo?: string;
-        statusCode?: number;
-    }, options?: ErrorOptions);
-}
-export declare class AuthError extends EdsgerError {
-    constructor(message: string, options?: ErrorOptions);
-}
-export declare class ConfigError extends EdsgerError {
-    readonly field?: string;
-    constructor(message: string, field?: string, options?: ErrorOptions);
-}
-export declare class PhaseError extends EdsgerError {
-    readonly phase: string;
-    readonly issueId: string;
-    readonly iteration?: number;
-    constructor(phase: string, issueId: string, message: string, iteration?: number, options?: ErrorOptions);
-}
-export declare class LLMParseError extends EdsgerError {
-    readonly rawResponse?: string;
-    constructor(message: string, rawResponse?: string, options?: ErrorOptions);
-}
-export declare class WorkerTimeoutError extends EdsgerError {
-    readonly issueId: string;
-    readonly timeoutMs: number;
-    constructor(issueId: string, timeoutMs: number, options?: ErrorOptions);
-}
-export declare class WorkerCrashError extends EdsgerError {
-    readonly issueId: string;
-    readonly exitCode: number | null;
-    constructor(issueId: string, exitCode: number | null, options?: ErrorOptions);
-}
-export declare class ValidationError extends EdsgerError {
-    readonly fields: string[];
-    constructor(message: string, fields?: string[], options?: ErrorOptions);
-}
-export declare class HookError extends EdsgerError {
-    readonly hookId: string;
-    readonly pluginName: string;
-    readonly phase: string;
-    constructor(hookId: string, pluginName: string, phase: string, message: string, options?: ErrorOptions);
-}

package/dist/errors/index.js

@@ -1,129 +0,0 @@
-/**
- * Edsger error classification system.
- *
- * All errors extend EdsgerError so callers can:
- *   catch (error) { if (error instanceof EdsgerError) { ... } }
- *
- * Each subclass carries a `code` discriminant for structured handling,
- * plus optional context fields relevant to that error category.
- */
-// ---- Base ----
-export class EdsgerError extends Error {
-    code;
-    constructor(code, message, options) {
-        super(message, options);
-        this.name = 'EdsgerError';
-        this.code = code;
-    }
-    /** Wrap an unknown thrown value into an EdsgerError, preserving cause chain. */
-    static from(code, context, thrown) {
-        const message = thrown instanceof Error ? thrown.message : String(thrown);
-        const cause = thrown instanceof Error ? thrown : undefined;
-        return new EdsgerError(code, `${context}: ${message}`, { cause });
-    }
-}
-// ---- API / MCP errors ----
-export class ApiError extends EdsgerError {
-    endpoint;
-    statusCode;
-    constructor(endpoint, message, statusCode, options) {
-        super('API_ERROR', message, options);
-        this.name = 'ApiError';
-        this.endpoint = endpoint;
-        this.statusCode = statusCode;
-    }
-}
-// ---- GitHub errors ----
-export class GitHubError extends EdsgerError {
-    owner;
-    repo;
-    statusCode;
-    constructor(message, details, options) {
-        super('GITHUB_ERROR', message, options);
-        this.name = 'GitHubError';
-        this.owner = details?.owner;
-        this.repo = details?.repo;
-        this.statusCode = details?.statusCode;
-    }
-}
-// ---- Auth errors ----
-export class AuthError extends EdsgerError {
-    constructor(message, options) {
-        super('AUTH_ERROR', message, options);
-        this.name = 'AuthError';
-    }
-}
-// ---- Config errors ----
-export class ConfigError extends EdsgerError {
-    field;
-    constructor(message, field, options) {
-        super('CONFIG_ERROR', message, options);
-        this.name = 'ConfigError';
-        this.field = field;
-    }
-}
-// ---- Phase execution errors ----
-export class PhaseError extends EdsgerError {
-    phase;
-    issueId;
-    iteration;
-    constructor(phase, issueId, message, iteration, options) {
-        super('PHASE_ERROR', message, options);
-        this.name = 'PhaseError';
-        this.phase = phase;
-        this.issueId = issueId;
-        this.iteration = iteration;
-    }
-}
-// ---- LLM response parsing errors ----
-export class LLMParseError extends EdsgerError {
-    rawResponse;
-    constructor(message, rawResponse, options) {
-        super('LLM_PARSE_ERROR', message, options);
-        this.name = 'LLMParseError';
-        this.rawResponse = rawResponse?.slice(0, 2000); // truncate to avoid huge payloads
-    }
-}
-// ---- Worker errors ----
-export class WorkerTimeoutError extends EdsgerError {
-    issueId;
-    timeoutMs;
-    constructor(issueId, timeoutMs, options) {
-        super('WORKER_TIMEOUT', `Worker for issue ${issueId} timed out after ${Math.round(timeoutMs / 1000)}s`, options);
-        this.name = 'WorkerTimeoutError';
-        this.issueId = issueId;
-        this.timeoutMs = timeoutMs;
-    }
-}
-export class WorkerCrashError extends EdsgerError {
-    issueId;
-    exitCode;
-    constructor(issueId, exitCode, options) {
-        super('WORKER_CRASH', `Worker for issue ${issueId} crashed with exit code ${exitCode}`, options);
-        this.name = 'WorkerCrashError';
-        this.issueId = issueId;
-        this.exitCode = exitCode;
-    }
-}
-// ---- Validation errors ----
-export class ValidationError extends EdsgerError {
-    fields;
-    constructor(message, fields = [], options) {
-        super('VALIDATION_ERROR', message, options);
-        this.name = 'ValidationError';
-        this.fields = fields;
-    }
-}
-// ---- Hook errors ----
-export class HookError extends EdsgerError {
-    hookId;
-    pluginName;
-    phase;
-    constructor(hookId, pluginName, phase, message, options) {
-        super('HOOK_ERROR', message, options);
-        this.name = 'HookError';
-        this.hookId = hookId;
-        this.pluginName = pluginName;
-        this.phase = phase;
-    }
-}

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { type CliOptions } from './types/index.js';
-export declare const runEdsger: (options: CliOptions) => Promise<void>;
-export type { CliOptions, EdsgerConfig, ReviewResult } from './types/index.js';

package/dist/phases/adr-generation/agent.d.ts

@@ -1,6 +0,0 @@
-import { type AdrOptionInput } from '../../api/adr.js';
-/**
- * Run the ADR agent. Returns the validated options, or null if the model
- * produced nothing parseable.
- */
-export declare function executeAdrQuery(userPrompt: string, systemPrompt: string, verbose?: boolean, cwd?: string): Promise<AdrOptionInput[] | null>;

package/dist/phases/adr-generation/agent.js

@@ -1,69 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { extractJSON, normalizeOptions } from './parse.js';
-// eslint-disable-next-line @typescript-eslint/require-await
-async function* promptStream(text) {
-    yield { type: 'user', message: { role: 'user', content: text } };
-}
-/**
- * Run the ADR agent. Returns the validated options, or null if the model
- * produced nothing parseable.
- */
-export async function executeAdrQuery(userPrompt, systemPrompt, verbose, cwd) {
-    let lastAssistant = '';
-    let result = null;
-    let turnCount = 0;
-    logInfo('Connecting to AI agent for decision analysis...');
-    for await (const message of query({
-        prompt: promptStream(userPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 1000,
-            permissionMode: 'bypassPermissions',
-            ...(cwd ? { cwd } : {}),
-        },
-    })) {
-        if (message.type === 'assistant' && message.message?.content) {
-            turnCount++;
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    lastAssistant += `${content.text}\n`;
-                    logDebug(`${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    const input = (content.input ?? {});
-                    const desc = input.description ?? input.command ?? 'Running...';
-                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            const text = message.subtype === 'success'
-                ? message.result || lastAssistant
-                : lastAssistant;
-            if (message.subtype === 'success') {
-                logInfo(`\nAnalysis completed after ${turnCount} turns, parsing...`);
-            }
-            else {
-                logError(`\nAnalysis incomplete: ${message.subtype}`);
-            }
-            const parsed = extractJSON(text);
-            if (parsed) {
-                const options = normalizeOptions(parsed);
-                if (options.length > 0) {
-                    result = options;
-                }
-            }
-        }
-    }
-    if (!result) {
-        logError('Could not extract decision options from the agent response.');
-    }
-    return result;
-}