edsger 0.76.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/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';

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

@@ -1,194 +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 { spawnSync } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-import { createPromptGenerator } from '../pr-shared/agent-utils.js';
-import { createEmptyRunState, createQualityBenchmarkMcpServer, } from './mcp-server.js';
-import { createQualityBenchmarkSystemPrompt, createQualityBenchmarkUserPrompt, extractReportJson, } from './prompts.js';
-import { createRunnerContext } from './tool-runner.js';
-import { RUBRIC_VERSION, } from './types.js';
-// SDK upper bound. Each phase usually takes ~1-3 turns; with up to 30
-// tools probed + run plus per-finding verification, 500 gives headroom while
-// still cutting off runaway loops.
-const MAX_TURNS = 500;
-// ---------------------------------------------------------------------------
-// Orchestration
-// ---------------------------------------------------------------------------
-// eslint-disable-next-line complexity
-export async function runQualityBenchmark(opts) {
-    const { productId, productName, repoRoot, branch, packageManager, installEnabled, onProgress, verbose, scanDirBase, commitShaOverride, } = opts;
-    // 1. Determine commit sha from the local checkout.
-    const commitSha = commitShaOverride ?? readGitHead(repoRoot);
-    if (!commitSha) {
-        return {
-            status: 'error',
-            message: `Could not read git HEAD at ${repoRoot} — is this a git repo?`,
-        };
-    }
-    // 2. Set up runner + MCP server.
-    const runId = randomUUID();
-    const startedAt = new Date().toISOString();
-    const runner = createRunnerContext({
-        repo_root: repoRoot,
-        package_manager: packageManager,
-        install_enabled: installEnabled,
-        run_id: runId,
-        base_dir: scanDirBase,
-    });
-    const state = createEmptyRunState();
-    let lastPhase = 'detection';
-    const emit = (event) => {
-        lastPhase = event.phase;
-        onProgress?.(event);
-        if (verbose) {
-            logInfo(`[${event.phase}] ${event.message}`);
-        }
-    };
-    const mcpServer = createQualityBenchmarkMcpServer({ runner, onProgress: emit, installEnabled }, state);
-    // 3. Run the SDK session.
-    const systemPrompt = createQualityBenchmarkSystemPrompt();
-    const userPrompt = createQualityBenchmarkUserPrompt({
-        productName,
-        productId,
-        repoRoot,
-        branch,
-        commitSha,
-        runId,
-        installEnabled,
-    });
-    let lastAssistantText = '';
-    try {
-        for await (const message of query({
-            prompt: createPromptGenerator(userPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: MAX_TURNS,
-                permissionMode: 'bypassPermissions',
-                cwd: repoRoot,
-                mcpServers: {
-                    'quality-benchmark': mcpServer,
-                },
-            },
-        })) {
-            if (message.type === 'assistant' && message.message?.content) {
-                for (const c of message.message.content) {
-                    if (c.type === 'text') {
-                        lastAssistantText += `${c.text}\n`;
-                        if (verbose) {
-                            logInfo(`🤖 ${c.text}`);
-                        }
-                    }
-                }
-            }
-            if (message.type === 'result') {
-                if (message.subtype !== 'success') {
-                    logError(`SDK session ended with subtype=${message.subtype}`);
-                }
-                if (message.subtype === 'success' &&
-                    'result' in message &&
-                    typeof message.result === 'string') {
-                    lastAssistantText = message.result || lastAssistantText;
-                }
-            }
-        }
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-            status: 'error',
-            message: `SDK error: ${msg}`,
-            runId,
-            commitSha,
-            lastPhase,
-        };
-    }
-    // 4. Extract + validate JSON report.
-    const raw = extractReportJson(lastAssistantText);
-    if (!raw || typeof raw !== 'object') {
-        return {
-            status: 'error',
-            message: 'SDK session did not emit a parseable JSON report',
-            runId,
-            commitSha,
-            lastPhase: 'synthesis',
-        };
-    }
-    const report = raw;
-    // Merge SDK-emitted fields with the state we accumulated server-side. The
-    // server-side state is authoritative for execution metadata; the LLM owns
-    // the scoring fields.
-    const merged = {
-        ...report,
-        rubric_version: RUBRIC_VERSION,
-        tool_versions: { ...state.tool_versions, ...(report.tool_versions ?? {}) },
-        unavailable_tools: dedupUnavailable([
-            ...state.unavailable_tools,
-            ...(report.unavailable_tools ?? []),
-        ]),
-        tool_outputs: { ...state.tool_outputs, ...(report.tool_outputs ?? {}) },
-        dropped_findings: Math.max(state.dropped_findings, report.dropped_findings ?? 0),
-    };
-    const completedAt = new Date().toISOString();
-    const durationSec = Math.round((new Date(completedAt).getTime() - new Date(startedAt).getTime()) / 1000);
-    logSuccess(`Benchmark complete — grade ${merged.overall_grade ?? '?'} (${merged.overall_score ?? '?'})`);
-    return {
-        status: 'success',
-        report: merged,
-        runId,
-        commitSha,
-        startedAt,
-        completedAt,
-        durationSeconds: durationSec,
-    };
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function readGitHead(repoRoot) {
-    const res = spawnSync('git', ['rev-parse', 'HEAD'], {
-        cwd: repoRoot,
-        encoding: 'utf8',
-    });
-    if (res.status !== 0) {
-        return null;
-    }
-    return res.stdout.trim() || null;
-}
-function dedupUnavailable(list) {
-    const seen = new Set();
-    const out = [];
-    for (const entry of list) {
-        if (seen.has(entry.name)) {
-            continue;
-        }
-        seen.add(entry.name);
-        out.push(entry);
-    }
-    return out;
-}