edsger 0.77.0 → 0.79.0

package/dist/phases/architecture-diagram/index.js

@@ -1,51 +0,0 @@
-/**
- * architecture-diagram phase: map a component/dependency diagram (C4-ish) —
- * the modules / services / packages / datastores / external systems that make
- * up the product and how they depend on one another. Persisted to the
- * diagrams tables with `type = 'architecture'`.
- */
-import { z } from 'zod';
-import { generateDiagram, } from '../diagram-shared/generate.js';
-import { buildDiagramSystemPrompt, buildDiagramUserPrompt, } from '../diagram-shared/prompts.js';
-const archNode = z.object({
-    slug: z.string().min(1),
-    name: z.string().min(1),
-    kind: z.enum(['module', 'service', 'package', 'ui', 'datastore', 'external']),
-    file: z.string().optional(),
-    description: z.string().optional(),
-    tech: z.string().optional(),
-    responsibilities: z.array(z.string()).optional(),
-});
-const archEdge = z.object({
-    fromSlug: z.string().min(1),
-    toSlug: z.string().min(1),
-    kind: z.enum(['depends-on', 'calls', 'imports', 'data']),
-    label: z.string().optional(),
-    sourceFile: z.string().optional(),
-});
-export function runArchitectureDiagramPhase(options) {
-    return generateDiagram({
-        ...options,
-        workspaceKey: 'architecture-diagram',
-        fenceName: 'architecture_diagram',
-        nounPlural: 'components',
-        edgeNounPlural: 'dependencies',
-        mcpConfig: {
-            name: 'architecture-diagram',
-            toolName: 'architecture_diagram',
-            summaryDescribe: '1-3 sentence narrative of the system architecture and its main building blocks.',
-            nodesSchema: z.array(archNode),
-            nodesDescribe: 'Every component: module / service / package / ui / datastore / external. slug MUST be unique.',
-            edgesSchema: z.array(archEdge),
-            edgesDescribe: 'Dependencies. kind = depends-on / calls / imports / data. fromSlug is the depender. Endpoints MUST reference emitted components.',
-        },
-        buildSystemPrompt: (a) => buildDiagramSystemPrompt('phase/architecture-diagram', 'architecture-diagram', a),
-        buildUserPrompt: (a) => buildDiagramUserPrompt({
-            ...a,
-            task: 'Map the architecture (component & dependency) diagram for',
-            mcpName: 'architecture-diagram',
-            toolName: 'architecture_diagram',
-            process: 'Detect the stack and the top-level structure (workspaces/packages, service boundaries, top-level src dirs, deployment units). Treat each meaningful unit as a component of the right kind (a UI/front-end, backend services, internal modules/packages, datastores, third-party/external systems). Wire dependency edges from the import graph, cross-service calls, and datastore/external access. Aim for a readable ~10-25 components — group leaf files into their module; do not draw a file-level graph.',
-        }),
-    });
-}

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

@@ -1,32 +0,0 @@
-/**
- * Autonomous Development Phase
- *
- * Runs a time-limited loop where Claude Code SDK analyzes the codebase,
- * decides the next actionable step toward the issue's objective (description),
- * implements it, and commits. All iterations build on the same branch.
- * A PR is created after the first iteration; subsequent pushes update it.
- */
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type PipelinePhaseOptions } from '../../types/pipeline.js';
-export interface AutonomousResult {
-    issueId: string;
-    status: 'success' | 'error';
-    message: string;
-    branchName: string;
-    totalIterations: number;
-    elapsedHours: number;
-    prUrl?: string;
-}
-/**
- * Main entry point for autonomous development phase
- */
-export declare function runAutonomousDevelopment(options: PipelinePhaseOptions, config: EdsgerConfig, _checklistContext?: ChecklistPhaseContext | null): Promise<{
-    issueId: string;
-    status: string;
-    message: string;
-    branchName?: string;
-    totalIterations?: number;
-    elapsedHours?: number;
-    prUrl?: string;
-}>;

package/dist/phases/autonomous/index.js

@@ -1,412 +0,0 @@
-/**
- * Autonomous Development Phase
- *
- * Runs a time-limited loop where Claude Code SDK analyzes the codebase,
- * decides the next actionable step toward the issue's objective (description),
- * implements it, and commits. All iterations build on the same branch.
- * A PR is created after the first iteration; subsequent pushes update it.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getGitHubConfig } from '../../api/github.js';
-import { getIssue } from '../../api/issues/get-issue.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logIssuePhaseEvent } from '../../services/audit-logs.js';
-import { createBranches, getCurrentBranch, updateBranch, } from '../../services/branches.js';
-import { getDefaultBranchForIssue } from '../../services/repo-config.js';
-import { prepareCustomBranchGitEnvironmentAsync, resetUncommittedChanges, } from '../../utils/git-branch-manager.js';
-import { gitPush } from '../../utils/git-push.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { createBranchPullRequest, } from '../code-implementation/branch-pr-creator.js';
-import { createAutonomousSystemPrompt, createAutonomousUserPrompt, } from './prompts.js';
-/**
- * Truncate text to a maximum length, adding ellipsis if truncated
- */
-function truncateText(text, maxLength) {
-    if (text.length <= maxLength) {
-        return text;
-    }
-    return `${text.slice(0, maxLength - 3)}...`;
-}
-// 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;
-}
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(userPrompt) {
-    yield userMessage(userPrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-/**
- * Run a single autonomous iteration using Claude Code SDK
- */
-async function runIteration(issueId, issueDescription, config, verbose) {
-    const systemPrompt = await createAutonomousSystemPrompt(issueId);
-    const userPromptText = createAutonomousUserPrompt(issueDescription);
-    let lastAssistantResponse = '';
-    for await (const message of query({
-        prompt: prompt(userPromptText),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 3000,
-            permissionMode: 'bypassPermissions',
-        },
-    })) {
-        if (verbose) {
-            logInfo(`Received message type: ${message.type}`);
-        }
-        if (message.type === 'assistant') {
-            lastAssistantResponse += processAssistantContent(message.message?.content ?? [], verbose);
-            continue;
-        }
-        if (message.type !== 'result') {
-            continue;
-        }
-        if (message.subtype !== 'success') {
-            logError(`⚠️  Autonomous iteration incomplete: ${message.subtype}`);
-            return { success: false };
-        }
-        return parseIterationResult(message.result || lastAssistantResponse);
-    }
-    return { success: false };
-}
-/**
- * Parse the result of an autonomous iteration
- */
-function parseIterationResult(responseText) {
-    try {
-        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const jsonResult = jsonBlockMatch
-            ? JSON.parse(jsonBlockMatch[1])
-            : JSON.parse(responseText);
-        if (jsonResult?.autonomous_result) {
-            const result = jsonResult.autonomous_result;
-            return {
-                success: true,
-                summary: result.summary,
-                taskType: result.task_type,
-                filesModified: result.files_modified,
-                commitHash: result.commit_hash,
-            };
-        }
-        logInfo('⚠️  JSON result missing autonomous_result key, treating as success');
-        return {
-            success: true,
-            summary: 'Autonomous iteration completed (missing result key)',
-        };
-    }
-    catch {
-        logInfo('⚠️  Could not parse structured result, treating as success');
-        return {
-            success: true,
-            summary: 'Autonomous iteration completed (unstructured result)',
-        };
-    }
-}
-/**
- * Handle a successful iteration: push, create PR, and log
- */
-async function handleSuccessfulIteration(opts) {
-    const { issueId, devBranchName, currentBranch, iterationResult, totalIterations, iterationDuration, startTime, endTime, existingPrUrl, defaultBranch, verbose, } = opts;
-    // Get GitHub config for push authentication and PR creation
-    const githubConfig = await getGitHubConfig(issueId, verbose);
-    // Push to remote with authentication
-    const pushResult = gitPush({
-        branchName: devBranchName,
-        token: githubConfig.configured ? githubConfig.token : undefined,
-        verbose,
-    });
-    if (!pushResult.success && verbose) {
-        logError(`⚠️  Failed to push: ${pushResult.error}`);
-    }
-    // Create PR after first successful iteration
-    let prUrl = existingPrUrl;
-    let prNumber;
-    if (!prUrl) {
-        const prInfo = await createAutonomousPR(githubConfig, devBranchName, currentBranch, defaultBranch, verbose);
-        ({ prUrl, prNumber } = prInfo);
-    }
-    // Log iteration completion to audit logs
-    await logIssuePhaseEvent({
-        issueId,
-        eventType: 'autonomous_iteration_completed',
-        phase: 'autonomous',
-        result: 'success',
-        metadata: {
-            iteration: totalIterations,
-            task_type: iterationResult.taskType,
-            summary: iterationResult.summary,
-            files_modified: iterationResult.filesModified || [],
-            commit_hash: iterationResult.commitHash || '',
-            duration_ms: iterationDuration,
-            pr_url: prUrl || null,
-            elapsed_hours: ((Date.now() - startTime) / 3600000).toFixed(2),
-            remaining_hours: ((endTime - Date.now()) / 3600000).toFixed(2),
-            timestamp: new Date().toISOString(),
-        },
-    }, verbose);
-    return { prUrl, prNumber };
-}
-/**
- * Create a PR for autonomous development work
- */
-async function createAutonomousPR(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-githubConfig, devBranchName, currentBranch, defaultBranch, verbose) {
-    if (!githubConfig.configured ||
-        !githubConfig.token ||
-        !githubConfig.owner ||
-        !githubConfig.repo) {
-        if (verbose) {
-            logInfo('⚠️  GitHub not configured, skipping PR creation');
-        }
-        return {};
-    }
-    const prConfig = {
-        githubToken: githubConfig.token,
-        owner: githubConfig.owner,
-        repo: githubConfig.repo,
-        verbose,
-    };
-    logInfo(`📝 Creating pull request for autonomous work...`);
-    const prResult = await createBranchPullRequest(prConfig, devBranchName, currentBranch.name, currentBranch.description || 'Autonomous development implementation', defaultBranch);
-    if (prResult.success) {
-        logInfo(`✅ Pull request created: ${prResult.pullRequestUrl}`);
-        return {
-            prUrl: prResult.pullRequestUrl,
-            prNumber: prResult.pullRequestNumber,
-        };
-    }
-    if (verbose) {
-        logError(`⚠️  Failed to create pull request: ${prResult.error}`);
-    }
-    return {};
-}
-/**
- * Handle a failed iteration: reset and log
- */
-async function handleFailedIteration(opts) {
-    const { issueId, totalIterations, iterationDuration, startTime, endTime, verbose, } = opts;
-    logError(`❌ Iteration ${totalIterations} failed`);
-    try {
-        resetUncommittedChanges(verbose);
-    }
-    catch {
-        // Ignore cleanup errors
-    }
-    await logIssuePhaseEvent({
-        issueId,
-        eventType: 'autonomous_iteration_failed',
-        phase: 'autonomous',
-        result: 'error',
-        metadata: {
-            iteration: totalIterations,
-            duration_ms: iterationDuration,
-            elapsed_hours: ((Date.now() - startTime) / 3600000).toFixed(2),
-            remaining_hours: ((endTime - Date.now()) / 3600000).toFixed(2),
-            timestamp: new Date().toISOString(),
-        },
-        errorMessage: 'Autonomous iteration failed',
-    }, verbose);
-}
-/**
- * Main entry point for autonomous development phase
- */
-// eslint-disable-next-line complexity -- orchestration function coordinating autonomous development lifecycle
-export async function runAutonomousDevelopment(options, config, _checklistContext) {
-    const { issueId, verbose } = options;
-    const startTime = Date.now();
-    logInfo(`\n🤖 Starting autonomous development for issue: ${issueId}`);
-    // 1. Fetch issue info to get description (= objective) and autonomous_hours
-    const issue = await getIssue(issueId, verbose);
-    const issueDescription = issue.description || '';
-    const autonomousHours = issue.autonomous_hours || 4;
-    if (!issueDescription) {
-        return {
-            issueId,
-            status: 'error',
-            message: 'Issue description is required for autonomous mode (it serves as the objective)',
-        };
-    }
-    const endTime = startTime + autonomousHours * 3600000;
-    logInfo(`⏰ Autonomous mode will run for ${autonomousHours} hour(s)`);
-    logInfo(`🎯 Objective: ${truncateText(issueDescription.replace(/<[^>]*>/g, ''), 200)}`);
-    // 2. Get or create branch
-    let currentBranch = null;
-    try {
-        currentBranch = await getCurrentBranch({ issueId, verbose });
-    }
-    catch {
-        if (verbose) {
-            logInfo('No existing branch found, will create one');
-        }
-    }
-    if (!currentBranch) {
-        const issueName = truncateText(issue.name || 'Autonomous Development', 100);
-        const defaultBranchName = `dev/${issueId}`;
-        const createdBranches = await createBranches({ issueId, verbose }, [
-            {
-                name: issueName,
-                description: `Autonomous development branch for: ${issueName}`,
-                branch_name: defaultBranchName,
-                status: 'pending',
-            },
-        ]);
-        if (createdBranches.length > 0) {
-            currentBranch = createdBranches[0];
-            if (verbose) {
-                logInfo(`✅ Created branch: ${currentBranch.branch_name}`);
-            }
-        }
-    }
-    if (!currentBranch) {
-        return {
-            issueId,
-            status: 'error',
-            message: 'Failed to create or find a branch for autonomous development',
-        };
-    }
-    const devBranchName = currentBranch.branch_name || `dev/${issueId}`;
-    // 3. Update branch status to in_progress
-    if (currentBranch.status === 'pending') {
-        try {
-            await updateBranch(currentBranch.id, { status: 'in_progress' }, verbose);
-        }
-        catch (error) {
-            if (verbose) {
-                logError(`Failed to update branch status: ${error}`);
-            }
-        }
-    }
-    // 4. Prepare git environment (checkout branch + rebase with default branch)
-    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
-    const { cleanup: cleanupGit } = await prepareCustomBranchGitEnvironmentAsync({
-        issueBranch: devBranchName,
-        baseBranch: defaultBranch,
-        verbose,
-        resolveConflicts: true,
-        conflictResolverConfig: {
-            model: DEFAULT_MODEL,
-        },
-    });
-    let totalIterations = 0;
-    let prUrl;
-    let prNumber;
-    try {
-        // 5. Main autonomous loop
-        while (Date.now() < endTime) {
-            totalIterations++;
-            const iterationStart = Date.now();
-            logInfo(`\n${'='.repeat(60)}\n🔄 Autonomous iteration ${totalIterations}\n${'='.repeat(60)}`);
-            // Run iteration
-            const iterationResult = await runIteration(issueId, issueDescription, config, verbose);
-            const iterationDuration = Date.now() - iterationStart;
-            logInfo(`⏱️  Iteration ${totalIterations} took ${(iterationDuration / 1000).toFixed(0)}s`);
-            if (iterationResult.success) {
-                logInfo(`✅ Iteration ${totalIterations}: ${iterationResult.summary || 'completed'}`);
-                const prInfo = await handleSuccessfulIteration({
-                    issueId,
-                    devBranchName,
-                    currentBranch,
-                    iterationResult,
-                    totalIterations,
-                    iterationDuration,
-                    startTime,
-                    endTime,
-                    existingPrUrl: prUrl,
-                    defaultBranch,
-                    verbose,
-                });
-                prUrl = prInfo.prUrl || prUrl;
-                prNumber = prInfo.prNumber || prNumber;
-            }
-            else {
-                await handleFailedIteration({
-                    issueId,
-                    totalIterations,
-                    iterationDuration,
-                    startTime,
-                    endTime,
-                    verbose,
-                });
-            }
-            // Check time before starting next iteration
-            if (Date.now() >= endTime) {
-                logInfo(`\n⏰ Time limit reached after ${totalIterations} iterations`);
-                break;
-            }
-        }
-        // 6. Update branch status to ready_for_review
-        try {
-            await updateBranch(currentBranch.id, {
-                status: 'ready_for_review',
-                pull_request_url: prUrl || null,
-                pull_request_number: prNumber || null,
-            }, verbose);
-            if (verbose) {
-                logInfo(`✅ Updated branch status to ready_for_review`);
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logError(`Failed to update branch status: ${error}`);
-            }
-        }
-        const elapsedHours = (Date.now() - startTime) / 3600000;
-        logInfo(`\n${'='.repeat(60)}`);
-        logInfo(`🏁 Autonomous development completed`);
-        logInfo(`   Total iterations: ${totalIterations}`);
-        logInfo(`   Elapsed time: ${elapsedHours.toFixed(2)} hours`);
-        logInfo(`   Branch: ${devBranchName}`);
-        if (prUrl) {
-            logInfo(`   PR: ${prUrl}`);
-        }
-        logInfo(`${'='.repeat(60)}\n`);
-        return {
-            issueId,
-            status: 'success',
-            message: `Autonomous development completed: ${totalIterations} iterations in ${elapsedHours.toFixed(2)} hours`,
-            branchName: devBranchName,
-            totalIterations,
-            elapsedHours,
-            prUrl,
-        };
-    }
-    catch (error) {
-        const elapsedHours = (Date.now() - startTime) / 3600000;
-        logError(`Autonomous development failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            issueId,
-            status: 'error',
-            message: `Autonomous development failed: ${error instanceof Error ? error.message : String(error)}`,
-            branchName: devBranchName,
-            totalIterations,
-            elapsedHours,
-        };
-    }
-    finally {
-        cleanupGit();
-    }
-}

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

@@ -1,5 +0,0 @@
-/**
- * Prompts for the autonomous development phase
- */
-export declare const createAutonomousSystemPrompt: (issueId: string, projectDir?: string) => Promise<string>;
-export declare function createAutonomousUserPrompt(issueDescription: string): string;

package/dist/phases/autonomous/prompts.js

@@ -1,31 +0,0 @@
-/**
- * Prompts for the autonomous development phase
- */
-import { resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createAutonomousSystemPrompt = async (issueId, projectDir) => {
-    const skill = await resolveSkill('phase/autonomous', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/autonomous');
-    }
-    let { prompt } = skill;
-    prompt = substituteVariables(prompt, { ISSUE_ID: issueId });
-    return `${prompt}
-
-${OUTPUT_CONTRACTS['autonomous']}`;
-};
-export function createAutonomousUserPrompt(issueDescription) {
-    return `## Objective
-
-${issueDescription}
-
-## Instructions
-
-Analyze the current state of the codebase. Based on the objective above, decide the next most valuable step to move toward the goal. Implement the change, verify it works, and commit it.
-
-Focus on ONE coherent, well-scoped change. Make real progress toward the objective.
-
-Begin by analyzing the codebase to understand the current state and decide your next step.`;
-}

package/dist/phases/branch-planning/context.d.ts

@@ -1,14 +0,0 @@
-import { type ProductInfo } from '../../api/products.js';
-import { type Branch } from '../../services/branches.js';
-import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
-export interface BranchPlanningContext {
-    issue: IssueInfo;
-    product: ProductInfo;
-    user_stories: UserStory[];
-    test_cases: TestCase[];
-    existing_branches: Branch[];
-}
-/**
- * Fetch all context information needed for branch planning via MCP endpoints
- */
-export declare function fetchBranchPlanningContext(issueId: string, verbose?: boolean): Promise<BranchPlanningContext>;

package/dist/phases/branch-planning/context.js

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

package/dist/phases/branch-planning/index.d.ts

@@ -1,25 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-export interface BranchPlanningOptions {
-    issueId: string;
-    verbose?: boolean;
-    replaceExisting?: boolean;
-}
-export interface PlannedBranch {
-    name: string;
-    description: string;
-    branch_name?: string;
-    depends_on?: string[];
-    depends_on_branch_name?: string | null;
-    scope?: string[];
-    acceptance_criteria?: string[];
-}
-export interface BranchPlanningResult {
-    issueId: string;
-    branches: PlannedBranch[];
-    status: 'success' | 'error';
-    summary: string;
-    rationale?: string;
-}
-export declare const planIssueBranches: (options: BranchPlanningOptions, config: EdsgerConfig) => Promise<BranchPlanningResult>;
-export type { BranchPlanningContext } from './context.js';
-export { fetchBranchPlanningContext } from './context.js';