edsger 0.77.0 → 0.78.0

package/dist/phases/pull-request/creator.js

@@ -1,319 +0,0 @@
-/**
- * Pull Request Creator for the development workflow
- * Creates pull requests from issue branches after successful testing
- */
-import { Octokit } from '@octokit/rest';
-import { execFileSync, execSync } from 'child_process';
-import { buildCredentialArgs, gitPush } from '../../utils/git-push.js';
-import { resolveDefaultBranch } from '../../utils/github-repo-info.js';
-import { logDebug } from '../../utils/logger.js';
-// GitHub PR title best practice: keep under 72 characters
-const MAX_PR_TITLE_LENGTH = 72;
-const PR_TITLE_PREFIX = 'feat: ';
-const MAX_ISSUE_NAME_LENGTH = MAX_PR_TITLE_LENGTH - PR_TITLE_PREFIX.length;
-/**
- * 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)}...`;
-}
-/**
- * Get current Git branch name
- */
-const getCurrentBranch = () => {
-    try {
-        return execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
-    }
-    catch (error) {
-        throw new Error(`Failed to get current branch: ${error}`);
-    }
-};
-/**
- * Check if a branch exists
- */
-const branchExists = (branch) => {
-    try {
-        execSync(`git rev-parse --verify ${branch}`, { encoding: 'utf-8' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-/**
- * Discard uncommitted changes in the working directory
- */
-const discardUncommittedChanges = (verbose) => {
-    try {
-        logDebug('Discarding uncommitted changes...', verbose);
-        // Reset all tracked files to HEAD
-        execSync('git reset --hard HEAD', { encoding: 'utf-8' });
-        // Remove all untracked files and directories
-        execSync('git clean -fd', { encoding: 'utf-8' });
-        logDebug('Working directory cleaned', verbose);
-    }
-    catch (error) {
-        throw new Error(`Failed to discard uncommitted changes: ${error}`);
-    }
-};
-/**
- * Switch to an existing branch
- * By default, checks remote if branch doesn't exist locally (handles multi-clone scenarios)
- * @param branch - The branch to switch to
- * @param verbose - Whether to log verbose output
- */
-const switchToBranch = (branch, verbose, githubToken) => {
-    try {
-        // First check if branch exists locally
-        if (!branchExists(branch)) {
-            // Branch doesn't exist locally, try to fetch and create tracking branch from remote
-            logDebug(`Branch '${branch}' not found locally, checking remote...`, verbose);
-            try {
-                // Fetch to get latest remote refs
-                const credArgs = buildCredentialArgs(githubToken);
-                execFileSync('git', [...credArgs, 'fetch', 'origin'], {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-                // Check if remote branch exists
-                execSync(`git rev-parse --verify origin/${branch}`, {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-                // Remote branch exists, create local tracking branch
-                logDebug(`Found branch '${branch}' on remote, creating local tracking branch...`, verbose);
-                // Discard any uncommitted changes before creating branch
-                discardUncommittedChanges(verbose);
-                execSync(`git checkout -b ${branch} --track origin/${branch}`, {
-                    encoding: 'utf-8',
-                });
-                logDebug(`Created and switched to tracking branch: ${branch}`, verbose);
-                return;
-            }
-            catch (_e) {
-                // Remote branch doesn't exist either
-                throw new Error(`Branch '${branch}' does not exist locally or on remote. The branch should have been created during code implementation phase.`);
-            }
-        }
-        logDebug(`Switching to branch: ${branch}`, verbose);
-        // Discard any uncommitted changes before switching
-        discardUncommittedChanges(verbose);
-        execSync(`git checkout ${branch}`, { encoding: 'utf-8' });
-        logDebug(`Switched to branch: ${branch}`, verbose);
-    }
-    catch (error) {
-        throw new Error(`Failed to switch to branch ${branch}: ${error}`);
-    }
-};
-/**
- * Switch to the repo's default branch (e.g. main, master). Caller passes the
- * resolved branch name; falls back to local origin/HEAD if undefined.
- */
-const switchToMainBranch = (mainBranch, verbose) => {
-    const target = mainBranch ?? resolveDefaultBranch();
-    try {
-        logDebug(`Switching to ${target} branch...`, verbose);
-        // Discard any uncommitted changes before switching
-        discardUncommittedChanges(verbose);
-        execFileSync('git', ['checkout', target], { encoding: 'utf-8' });
-        logDebug(`Switched to ${target} branch`, verbose);
-    }
-    catch (error) {
-        throw new Error(`Failed to switch to ${target} branch: ${error}`);
-    }
-};
-/**
- * Generate pull request title from issue name
- * Truncates to keep under 72 characters (GitHub best practice)
- */
-const generatePRTitle = (issueName) => {
-    // Remove issue ID prefix if present (e.g., "FEAT-123: Issue Name" -> "Issue Name")
-    const cleanName = issueName.replace(/^[A-Z]+-\d+:\s*/, '');
-    // Truncate to keep total title under 72 chars
-    const truncatedName = truncateText(cleanName.toLowerCase(), MAX_ISSUE_NAME_LENGTH);
-    return `${PR_TITLE_PREFIX}${truncatedName}`;
-};
-const findExistingPullRequest = async (opts) => {
-    const { octokit, owner, repo, head, base, verbose } = opts;
-    try {
-        logDebug(`Checking for existing PR from ${head} to ${base}...`, verbose);
-        const { data: pullRequests } = await octokit.pulls.list({
-            owner,
-            repo,
-            head: `${owner}:${head}`,
-            base,
-            state: 'open',
-        });
-        if (pullRequests.length > 0) {
-            const existingPR = pullRequests[0];
-            logDebug(`Found existing PR #${existingPR.number}: ${existingPR.html_url}`, verbose);
-            return {
-                number: existingPR.number,
-                html_url: existingPR.html_url,
-            };
-        }
-        logDebug('No existing PR found', verbose);
-        return null;
-    }
-    catch (error) {
-        logDebug(`Error checking for existing PR: ${error}`, verbose);
-        // If we can't check, return null and proceed with creation attempt
-        return null;
-    }
-};
-/**
- * Generate pull request body with issue details
- */
-const generatePRBody = (issue) => {
-    const sections = [];
-    // Issue URL section
-    const appUrl = process.env.NEXTAUTH_URL || process.env.APP_URL || 'http://localhost:3000';
-    if (issue.productId) {
-        sections.push('## Issue Details');
-        sections.push(`📋 [View Issue Details](${appUrl}/products/${issue.productId}/issues/${issue.id})`);
-        sections.push('');
-    }
-    // Test Report section (if available)
-    if (issue.testReportUrl) {
-        sections.push('## Test Report');
-        sections.push(`🧪 [View Detailed Test Report](${issue.testReportUrl})`);
-        sections.push('');
-    }
-    // Metadata
-    sections.push('---');
-    sections.push(`Issue ID: ${issue.id}`);
-    sections.push(`Created by: Automated Workflow`);
-    return sections.join('\n');
-};
-/**
- * Create a pull request for the issue
- */
-export async function createPullRequest(config, issue) {
-    const { githubToken, owner, repo, baseBranch = resolveDefaultBranch(), verbose, } = config;
-    try {
-        // Initialize Octokit with personal access token
-        const octokit = new Octokit({
-            auth: githubToken,
-        });
-        // Get current branch (should be dev/issue-id)
-        let currentBranch = getCurrentBranch();
-        logDebug(`Current branch: ${currentBranch}`, verbose);
-        // If we're on the base branch, switch to dev branch (should already exist)
-        // Default behavior now checks remote if not found locally (multi-clone scenario)
-        if (currentBranch === baseBranch) {
-            const devBranch = `dev/${issue.id}`;
-            logDebug(`Currently on ${baseBranch} branch, switching to ${devBranch}`, verbose);
-            switchToBranch(devBranch, verbose, githubToken);
-            currentBranch = devBranch;
-        }
-        // Extract issue ID from current branch (dev/issue-id)
-        let targetBranch = baseBranch;
-        if (currentBranch.startsWith('dev/')) {
-            const issueId = currentBranch.replace('dev/', '');
-            targetBranch = `feat/${issueId}`;
-            // Create the feat/ branch from base branch (main)
-            logDebug(`Creating target branch: ${targetBranch} from ${baseBranch}`, verbose);
-            try {
-                // Push current branch to remote first
-                const pushResult = gitPush({
-                    branchName: currentBranch,
-                    token: githubToken,
-                    verbose,
-                });
-                if (!pushResult.success) {
-                    throw new Error(`Failed to push branch: ${pushResult.error}`);
-                }
-                // Get the base branch (main) SHA to create feat/ branch from
-                const { data: baseBranchData } = await octokit.repos.getBranch({
-                    owner,
-                    repo,
-                    branch: baseBranch,
-                });
-                // Create the feat/ branch from main
-                await octokit.git.createRef({
-                    owner,
-                    repo,
-                    ref: `refs/heads/${targetBranch}`,
-                    sha: baseBranchData.commit.sha,
-                });
-                logDebug(`Created target branch: ${targetBranch} from ${baseBranch}`, verbose);
-            }
-            catch (error) {
-                // If branch already exists, that's fine
-                if (!(error instanceof Error) ||
-                    !error.message?.includes('Reference already exists')) {
-                    throw error;
-                }
-                logDebug(`Target branch ${targetBranch} already exists`, verbose);
-            }
-        }
-        else {
-            // If not a dev/ branch, push it normally
-            const pushResult = gitPush({
-                branchName: currentBranch,
-                token: githubToken,
-                verbose,
-            });
-            if (!pushResult.success) {
-                throw new Error(`Failed to push branch: ${pushResult.error}`);
-            }
-        }
-        // Generate PR title and body
-        const title = generatePRTitle(issue.name);
-        const body = generatePRBody(issue);
-        // Check if PR already exists
-        const existingPR = await findExistingPullRequest({
-            octokit,
-            owner,
-            repo,
-            head: currentBranch,
-            base: targetBranch,
-            verbose,
-        });
-        let pullRequest;
-        if (existingPR) {
-            logDebug(`Using existing pull request: ${existingPR.html_url}`, verbose);
-            pullRequest = existingPR;
-        }
-        else {
-            logDebug(`Creating pull request: ${title} from ${currentBranch} to ${targetBranch}`, verbose);
-            // Create the pull request from dev/ to feat/
-            const { data: newPullRequest } = await octokit.pulls.create({
-                owner,
-                repo,
-                title,
-                body,
-                head: currentBranch,
-                base: targetBranch,
-                draft: false,
-            });
-            logDebug(`Pull request created: ${newPullRequest.html_url}`, verbose);
-            pullRequest = newPullRequest;
-        }
-        // Switch back to main branch
-        switchToMainBranch(baseBranch, verbose);
-        return {
-            success: true,
-            pullRequestUrl: pullRequest.html_url,
-            pullRequestNumber: pullRequest.number,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logDebug(`Failed to create pull request: ${errorMessage}`, verbose);
-        // Try to switch back to main branch even if PR creation failed
-        try {
-            switchToMainBranch(baseBranch, verbose);
-        }
-        catch {
-            // Ignore error if we can't switch back
-        }
-        return {
-            success: false,
-            error: errorMessage,
-        };
-    }
-}

package/dist/phases/pull-request/handler.d.ts

@@ -1,15 +0,0 @@
-/**
- * Pull request creation handler for pipeline execution
- */
-import { type PipelineResult } from '../../types/pipeline.js';
-export interface PullRequestHandlerOptions {
-    issueId: string;
-    results: readonly PipelineResult[];
-    testingResult?: PipelineResult;
-    verbose?: boolean;
-}
-/**
- * Create pull request for successful issue implementation
- * Returns true if PR was successfully created, false otherwise
- */
-export declare function handlePullRequestCreation({ issueId, results, testingResult, verbose, }: PullRequestHandlerOptions): Promise<boolean>;

package/dist/phases/pull-request/handler.js

@@ -1,92 +0,0 @@
-/**
- * Pull request creation handler for pipeline execution
- */
-import { getGitHubConfig } from '../../api/github.js';
-import { getIssue } from '../../api/issues/index.js';
-import { getCurrentBranch, updateBranch, } from '../../services/branches.js';
-import { getDefaultBranchForIssue } from '../../services/repo-config.js';
-import { logDebug } from '../../utils/logger.js';
-import { createPullRequest } from './creator.js';
-/**
- * Create pull request for successful issue implementation
- * Returns true if PR was successfully created, false otherwise
- */
-// eslint-disable-next-line complexity -- orchestration function with branch detection, PR creation, and status updates
-export async function handlePullRequestCreation({ issueId, results, testingResult, verbose, }) {
-    logDebug('Creating pull request for successful issue...', verbose);
-    // Get issue details for PR creation
-    const issue = await getIssue(issueId, verbose);
-    if (!issue) {
-        logDebug('Could not fetch issue details for pull request creation', verbose);
-        return false;
-    }
-    // Get current branch for the issue
-    let currentBranch = null;
-    try {
-        currentBranch = await getCurrentBranch({ issueId, verbose });
-    }
-    catch (error) {
-        logDebug(`Could not fetch branch for issue: ${error}`, verbose);
-    }
-    // Check if PR already exists on the branch
-    if (currentBranch?.pull_request_url) {
-        logDebug(`Pull request already exists: ${currentBranch.pull_request_url}`, verbose);
-        logDebug('Skipping PR creation, using existing pull request', verbose);
-        return true;
-    }
-    // Get GitHub configuration from product developer settings
-    const githubConfig = await getGitHubConfig(issueId, verbose);
-    if (!githubConfig.configured ||
-        !githubConfig.token ||
-        !githubConfig.owner ||
-        !githubConfig.repo) {
-        logDebug('GitHub configuration not found. Skipping pull request creation.', verbose);
-        logDebug(`${githubConfig.message || 'Please configure a developer with GitHub App installation in the product settings.'}`, verbose);
-        return false;
-    }
-    const { token: githubToken, owner: githubOwner, repo: githubRepo, } = githubConfig;
-    logDebug(`Using GitHub config from product developer: ${githubOwner}/${githubRepo}`, verbose);
-    const baseBranch = await getDefaultBranchForIssue(issueId, verbose);
-    const prResult = await createPullRequest({
-        githubToken,
-        owner: githubOwner,
-        repo: githubRepo,
-        baseBranch,
-        verbose,
-    }, {
-        id: issue.id,
-        name: issue.name,
-        description: issue.description || '',
-        productId: issue.product_id,
-        // Get technical design and test result from previous phases (if available)
-        technicalDesign: results.find((r) => r.phase === 'technical-design')?.data?.technicalDesign,
-        testResult: testingResult
-            ? testingResult.data
-                ?.testResult
-            : undefined,
-        testReportUrl: testingResult
-            ? testingResult.data
-                ?.testReport?.testReportUrl
-            : undefined,
-    });
-    if (prResult.success && prResult.pullRequestUrl) {
-        // Update branch with PR URL and status (if branch exists)
-        if (currentBranch) {
-            try {
-                await updateBranch(currentBranch.id, {
-                    pull_request_url: prResult.pullRequestUrl,
-                    pull_request_number: prResult.pullRequestNumber,
-                    status: 'ready_for_review',
-                }, verbose);
-                logDebug('Branch updated with PR URL', verbose);
-            }
-            catch (error) {
-                logDebug(`Failed to update branch with PR URL: ${error}`, verbose);
-            }
-        }
-        logDebug(`Pull request created${currentBranch ? ' and branch updated' : ''}`, verbose);
-        return true;
-    }
-    logDebug(`Pull request creation failed: ${prResult.error}`, verbose);
-    return false;
-}

package/dist/phases/quality-benchmark/gate.d.ts

@@ -1,50 +0,0 @@
-/**
- * Quality gate evaluation for the CLI.
- *
- * Lets `edsger quality-benchmark --gate` enforce a per-scope pass/fail
- * threshold against the report it just produced — the "fail the build" gate
- * NDepend/DCM-style tools expose, usable directly in a user's own CI without
- * any webhook. The gate (overall-score floor, critical-finding cap, per-
- * dimension minimums) is stored in `quality_gates`, mirroring the desktop
- * evaluator in desktop-app/.../services/db/quality-gate.ts.
- *
- * The evaluator is pure + exported for testing; the read is RLS-scoped via the
- * user's supabase session and never throws (a missing gate = nothing to
- * enforce).
- */
-import type { ScanScope } from '../find-shared/baseline.js';
-import type { Dimension, QualityReportPayload } from './types.js';
-export interface QualityGate {
-    enabled: boolean;
-    /** Minimum overall score (0–100); null = unconstrained. */
-    min_overall_score: number | null;
-    /** Maximum critical-severity findings allowed; null = unconstrained. */
-    max_critical_findings: number | null;
-    /** Per-dimension minimum scores; absent dimensions are unconstrained. */
-    min_dimension_scores: Partial<Record<Dimension, number>>;
-}
-export interface GateViolation {
-    /** Axis that failed, e.g. "Overall score" or "security". */
-    label: string;
-    /** The threshold that was required. */
-    required: string;
-    /** The actual value from the report. */
-    actual: string;
-}
-export interface GateResult {
-    passed: boolean;
-    violations: GateViolation[];
-}
-/** Count critical-severity findings across every dimension's evidence. */
-export declare function countCriticalFindings(report: QualityReportPayload): number;
-/**
- * Evaluate a report against a gate, returning every violated axis. A disabled
- * gate passes vacuously. A report with no overall score is not failed on the
- * overall-score axis (there is nothing to compare). Pure + exported for tests.
- */
-export declare function evaluateGate(report: QualityReportPayload, gate: QualityGate): GateResult;
-/**
- * Fetch the gate configured for a scope, or null if none is set / no session.
- * Never throws — a read failure degrades to "no gate" (nothing enforced).
- */
-export declare function getQualityGate(scope: ScanScope): Promise<QualityGate | null>;

package/dist/phases/quality-benchmark/gate.js

@@ -1,91 +0,0 @@
-/**
- * Quality gate evaluation for the CLI.
- *
- * Lets `edsger quality-benchmark --gate` enforce a per-scope pass/fail
- * threshold against the report it just produced — the "fail the build" gate
- * NDepend/DCM-style tools expose, usable directly in a user's own CI without
- * any webhook. The gate (overall-score floor, critical-finding cap, per-
- * dimension minimums) is stored in `quality_gates`, mirroring the desktop
- * evaluator in desktop-app/.../services/db/quality-gate.ts.
- *
- * The evaluator is pure + exported for testing; the read is RLS-scoped via the
- * user's supabase session and never throws (a missing gate = nothing to
- * enforce).
- */
-import { readScopedRow } from '../find-shared/scoped-read.js';
-/** Count critical-severity findings across every dimension's evidence. */
-export function countCriticalFindings(report) {
-    let count = 0;
-    for (const dim of Object.values(report.dimension_scores ?? {})) {
-        for (const ev of dim?.evidence ?? []) {
-            if (ev.severity === 'critical') {
-                count++;
-            }
-        }
-    }
-    return count;
-}
-/**
- * Evaluate a report against a gate, returning every violated axis. A disabled
- * gate passes vacuously. A report with no overall score is not failed on the
- * overall-score axis (there is nothing to compare). Pure + exported for tests.
- */
-export function evaluateGate(report, gate) {
-    const violations = [];
-    if (!gate.enabled) {
-        return { passed: true, violations };
-    }
-    if (gate.min_overall_score !== null &&
-        report.overall_score !== null &&
-        report.overall_score < gate.min_overall_score) {
-        violations.push({
-            label: 'Overall score',
-            required: `>= ${gate.min_overall_score}`,
-            actual: report.overall_score.toFixed(1),
-        });
-    }
-    if (gate.max_critical_findings !== null) {
-        const critical = countCriticalFindings(report);
-        if (critical > gate.max_critical_findings) {
-            violations.push({
-                label: 'Critical findings',
-                required: `<= ${gate.max_critical_findings}`,
-                actual: String(critical),
-            });
-        }
-    }
-    for (const [dim, min] of Object.entries(gate.min_dimension_scores)) {
-        if (min === null || min === undefined) {
-            continue;
-        }
-        const entry = report.dimension_scores?.[dim];
-        // A null/N-A dimension score isn't measurable against a floor — skip it.
-        if (entry?.score === null || entry?.score === undefined) {
-            continue;
-        }
-        if (entry.score < min) {
-            violations.push({
-                label: dim,
-                required: `>= ${min}`,
-                actual: entry.score.toFixed(0),
-            });
-        }
-    }
-    return { passed: violations.length === 0, violations };
-}
-/**
- * Fetch the gate configured for a scope, or null if none is set / no session.
- * Never throws — a read failure degrades to "no gate" (nothing enforced).
- */
-export async function getQualityGate(scope) {
-    const row = await readScopedRow('quality_gates', 'enabled, min_overall_score, max_critical_findings, min_dimension_scores', scope);
-    if (!row) {
-        return null;
-    }
-    return {
-        enabled: row.enabled ?? true,
-        min_overall_score: row.min_overall_score ?? null,
-        max_critical_findings: row.max_critical_findings ?? null,
-        min_dimension_scores: row.min_dimension_scores ?? {},
-    };
-}

package/dist/phases/quality-benchmark/index.d.ts

@@ -1,65 +0,0 @@
-/**
- * Quality benchmark phase entry point.
- *
- * Drives a single Claude Agent SDK session whose system prompt is the
- * full rubric (loaded by `prompts.ts`) and whose tool surface is the
- * in-process MCP server in `mcp-server.ts`. The session walks the
- * rubric's 6-phase pipeline by calling MCP tools; we observe the
- * messages for progress events and capture the final JSON report.
- *
- * Pure compute boundary: this function does NOT touch the database.
- * Callers (the CLI command, the desktop-app IPC bridge) decide how to
- * persist the returned payload — see the CLI command in
- * `src/commands/quality-benchmark/index.ts` for the MCP-mediated
- * persistence path.
- *
- * Side effects that DO happen here:
- *   - Creates a scratch dir under ~/.edsger/quality-runs/<run-id>/
- *   - Writes raw tool outputs to that dir
- *   - Spawns child_process invocations of the catalog tools
- */
-import { type ProgressEvent } from './mcp-server.js';
-import { type QualityReportPayload, type RunPhase } from './types.js';
-export interface QualityBenchmarkOptions {
-    productId: string;
-    productName: string;
-    /** Absolute path to the local repo checkout. */
-    repoRoot: string;
-    /** Branch name (informational; doesn't checkout). */
-    branch?: string;
-    /**
-     * Detected JS package manager (informational; the SDK will detect on its
-     * own but we pass through for catalog filtering).
-     */
-    packageManager?: string;
-    /** When false, install_tool always refuses (mirrors --no-install CLI flag). */
-    installEnabled: boolean;
-    /**
-     * Optional progress callback for the calling surface (CLI logger,
-     * Electron IPC, etc.). Receives every MCP-server-emitted event.
-     */
-    onProgress?: (event: ProgressEvent) => void;
-    verbose?: boolean;
-    /** Override scratch-dir base (mainly for tests). */
-    scanDirBase?: string;
-    /** Override commit sha resolution (mainly for tests). */
-    commitShaOverride?: string;
-}
-export type QualityBenchmarkOutcome = {
-    status: 'success';
-    report: QualityReportPayload;
-    runId: string;
-    commitSha: string;
-    startedAt: string;
-    completedAt: string;
-    durationSeconds: number;
-} | {
-    status: 'error';
-    message: string;
-    runId?: string;
-    commitSha?: string;
-    lastPhase?: RunPhase;
-};
-export declare function runQualityBenchmark(opts: QualityBenchmarkOptions): Promise<QualityBenchmarkOutcome>;
-export type { ProgressEvent } from './mcp-server.js';
-export type { QualityReportPayload, RunPhase } from './types.js';