edsger 0.77.0 → 0.78.0

package/dist/utils/git-push.js

@@ -1,136 +0,0 @@
-/**
- * Shared git push utilities with GitHub App credential helper support.
- *
- * Uses `git -c credential.helper=...` to pass the token securely per-command,
- * matching the pattern established in workspace-manager.ts for clone/fetch.
- * Uses `execFileSync` instead of `execSync` to avoid shell metacharacter injection.
- */
-import { execFileSync } from 'child_process';
-import { logInfo } from './logger.js';
-/**
- * Build git args with optional credential helper prefix.
- * When a token is provided, prepends `-c credential.helper=...` so git
- * authenticates with the GitHub App installation token.
- */
-export function buildCredentialArgs(token) {
-    if (!token) {
-        return [];
-    }
-    // First clear any existing credential helpers (e.g. osxkeychain) with an empty value,
-    // then set our custom helper. This ensures the token is used instead of stale keychain creds.
-    const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=${token}"; }; f`;
-    return [
-        '-c',
-        'credential.helper=',
-        '-c',
-        `credential.helper=${credentialHelper}`,
-    ];
-}
-/**
- * Push a branch to remote with three-level fallback:
- *   1. git push -u origin <branch>
- *   2. git push origin <branch>
- *   3. git push --force-with-lease origin <branch>
- *
- * When `token` is provided, each command uses a credential helper for authentication.
- */
-export function gitPush(options) {
-    const { branchName, token, verbose, cwd } = options;
-    const credArgs = buildCredentialArgs(token);
-    const execOpts = {
-        cwd,
-        stdio: verbose ? 'inherit' : 'pipe',
-    };
-    if (verbose) {
-        logInfo(`📤 Pushing branch ${branchName} to remote...`);
-    }
-    // Try 1: push -u (set upstream tracking)
-    try {
-        execFileSync('git', [...credArgs, 'push', '-u', 'origin', branchName], execOpts);
-        return { success: true, method: 'push-u' };
-    }
-    catch {
-        // fall through
-    }
-    // Try 2: plain push
-    try {
-        execFileSync('git', [...credArgs, 'push', 'origin', branchName], execOpts);
-        return { success: true, method: 'push' };
-    }
-    catch {
-        // fall through
-    }
-    // Try 3: force push with lease
-    if (verbose) {
-        logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-    }
-    try {
-        execFileSync('git', [...credArgs, 'push', '--force-with-lease', 'origin', branchName], execOpts);
-        if (verbose) {
-            logInfo(`✅ Successfully force pushed ${branchName}`);
-        }
-        return { success: true, method: 'force-with-lease' };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Force push a branch using --force-with-lease.
- * Used after rebase operations to update the remote branch.
- */
-export function gitForcePush(options) {
-    const { branchName, token, verbose, cwd } = options;
-    const credArgs = buildCredentialArgs(token);
-    const execOpts = {
-        cwd,
-        stdio: verbose ? 'inherit' : 'pipe',
-    };
-    if (verbose) {
-        logInfo(`📤 Force pushing ${branchName} to remote...`);
-    }
-    try {
-        execFileSync('git', [...credArgs, 'push', '--force-with-lease', 'origin', branchName], execOpts);
-        if (verbose) {
-            logInfo(`✅ Successfully force pushed ${branchName}`);
-        }
-        return { success: true, method: 'force-with-lease' };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Push the current branch to remote.
- * Resolves the current branch name first, then delegates to gitPush.
- */
-export function gitPushCurrentBranch(options) {
-    const { token, verbose, cwd } = options;
-    let branchName;
-    try {
-        branchName = execFileSync('git', ['branch', '--show-current'], {
-            encoding: 'utf-8',
-            cwd,
-            stdio: 'pipe',
-        }).trim();
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to resolve current branch: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    if (!branchName) {
-        return {
-            success: false,
-            error: 'Could not determine current branch (detached HEAD?)',
-        };
-    }
-    return gitPush({ branchName, token, verbose, cwd });
-}

package/dist/utils/github-repo-info.d.ts

@@ -1,26 +0,0 @@
-/**
- * GitHub repository information utilities
- */
-export interface RepoForkInfo {
-    isFork: boolean;
-    upstream?: {
-        owner: string;
-        repo: string;
-    };
-    defaultBranch?: string;
-}
-/**
- * Detect if a repository is a fork and get upstream + default branch info
- */
-export declare function getRepoForkInfo(token: string, owner: string, repo: string): Promise<RepoForkInfo>;
-/**
- * Resolve the repo's default branch with a multi-tier fallback:
- *   1. `apiValue` from GitHub API (most authoritative)
- *   2. local `git symbolic-ref refs/remotes/origin/HEAD`
- *   3. literal `'main'`
- *
- * Use this anywhere we need to diff/merge against the upstream default branch.
- * The hardcoded `origin/main` assumption breaks for repos whose default is
- * `master`, `develop`, etc., or for forks that inherited a non-`main` default.
- */
-export declare function resolveDefaultBranch(apiValue?: string): string;

package/dist/utils/github-repo-info.js

@@ -1,45 +0,0 @@
-/**
- * GitHub repository information utilities
- */
-import { Octokit } from '@octokit/rest';
-import { execFileSync } from 'child_process';
-/**
- * Detect if a repository is a fork and get upstream + default branch info
- */
-export async function getRepoForkInfo(token, owner, repo) {
-    const octokit = new Octokit({ auth: token });
-    const { data } = await octokit.repos.get({ owner, repo });
-    const result = {
-        isFork: false,
-        defaultBranch: data.default_branch,
-    };
-    if (data.fork && data.parent) {
-        const [upstreamOwner, upstreamRepo] = data.parent.full_name.split('/');
-        result.isFork = true;
-        result.upstream = { owner: upstreamOwner, repo: upstreamRepo };
-    }
-    return result;
-}
-/**
- * Resolve the repo's default branch with a multi-tier fallback:
- *   1. `apiValue` from GitHub API (most authoritative)
- *   2. local `git symbolic-ref refs/remotes/origin/HEAD`
- *   3. literal `'main'`
- *
- * Use this anywhere we need to diff/merge against the upstream default branch.
- * The hardcoded `origin/main` assumption breaks for repos whose default is
- * `master`, `develop`, etc., or for forks that inherited a non-`main` default.
- */
-export function resolveDefaultBranch(apiValue) {
-    if (apiValue) {
-        return apiValue;
-    }
-    try {
-        const ref = execFileSync('git', ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], { encoding: 'utf-8', stdio: 'pipe' }).trim();
-        const stripped = ref.replace(/^origin\//, '');
-        return stripped || 'main';
-    }
-    catch {
-        return 'main';
-    }
-}

package/dist/utils/image-downloader.d.ts

@@ -1,32 +0,0 @@
-/**
- * Downloaded image info
- */
-export interface DownloadedImage {
-    url: string;
-    localPath: string;
-    alt: string;
-}
-/**
- * Set current issue ID for image downloads
- * Should be called at the start of pipeline execution
- */
-export declare function setCurrentIssueId(issueId: string): void;
-/**
- * Reset image cache (useful for testing)
- */
-export declare function resetImageCache(): void;
-/**
- * Download images from URLs to temporary directory for Claude Code to read
- * Uses cache to avoid downloading same image multiple times
- *
- * @param markdown - Markdown content with image URLs
- * @param issueId - Issue ID for directory naming
- */
-export declare function downloadImagesForClaudeCode(markdown: string, issueId?: string): Promise<{
-    processedMarkdown: string;
-    downloadedImages: DownloadedImage[];
-}>;
-/**
- * Clean markdown by removing width attributes
- */
-export declare function cleanMarkdownForClaudeCode(markdown: string): string;

package/dist/utils/image-downloader.js

@@ -1,152 +0,0 @@
-import { createHash } from 'crypto';
-import { createWriteStream } from 'fs';
-import { access, mkdir } from 'fs/promises';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { pipeline } from 'stream/promises';
-import { logError, logInfo } from './logger.js';
-/**
- * Detect image file extension from URL or content-type header
- */
-function detectImageExtension(url, contentType) {
-    const urlExt = url.split('.').pop()?.toLowerCase();
-    if (urlExt && ['jpg', 'jpeg', 'png', 'gif', 'webp'].includes(urlExt)) {
-        return urlExt;
-    }
-    if (contentType?.includes('jpeg')) {
-        return 'jpg';
-    }
-    if (contentType?.includes('png')) {
-        return 'png';
-    }
-    if (contentType?.includes('gif')) {
-        return 'gif';
-    }
-    if (contentType?.includes('webp')) {
-        return 'webp';
-    }
-    return 'png';
-}
-// Cache for downloaded images in current session
-// Key: image URL, Value: local path
-const imageCache = new Map();
-// Current issue ID for directory naming
-let currentIssueId = null;
-/**
- * Generate hash from URL to use as filename
- * This ensures same URL always maps to same file
- */
-function hashUrl(url) {
-    return createHash('md5').update(url).digest('hex');
-}
-/**
- * Get or create temp directory for current issue
- */
-function getTempDir(issueId) {
-    return join(tmpdir(), 'claude-code-images', `issue-${issueId}`);
-}
-/**
- * Set current issue ID for image downloads
- * Should be called at the start of pipeline execution
- */
-export function setCurrentIssueId(issueId) {
-    if (currentIssueId !== issueId) {
-        // Clear cache when switching to different issue
-        imageCache.clear();
-        currentIssueId = issueId;
-    }
-}
-/**
- * Reset image cache (useful for testing)
- */
-export function resetImageCache() {
-    imageCache.clear();
-    currentIssueId = null;
-}
-/**
- * Download images from URLs to temporary directory for Claude Code to read
- * Uses cache to avoid downloading same image multiple times
- *
- * @param markdown - Markdown content with image URLs
- * @param issueId - Issue ID for directory naming
- */
-export async function downloadImagesForClaudeCode(markdown, issueId) {
-    if (!markdown) {
-        return { processedMarkdown: markdown, downloadedImages: [] };
-    }
-    // Use provided issueId or fall back to currentIssueId or timestamp
-    const effectiveIssueId = issueId || currentIssueId || Date.now().toString();
-    // Extract all image URLs from markdown
-    const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)(?:\{width=\d+\})?/g;
-    const matches = Array.from(markdown.matchAll(imageRegex));
-    if (matches.length === 0) {
-        return { processedMarkdown: markdown, downloadedImages: [] };
-    }
-    // Create temp directory for this issue
-    const tempDir = getTempDir(effectiveIssueId);
-    await mkdir(tempDir, { recursive: true });
-    const downloadedImages = [];
-    let processedMarkdown = markdown;
-    // Download each image (or use cached version)
-    for (let i = 0; i < matches.length; i++) {
-        const match = matches[i];
-        const alt = match[1] || '';
-        const url = match[2];
-        try {
-            // Check if image is already cached
-            let localPath = imageCache.get(url);
-            if (localPath) {
-                // Verify cached file still exists
-                try {
-                    await access(localPath);
-                    logInfo(`Using cached image: ${url}`);
-                }
-                catch {
-                    // Cached file no longer exists, remove from cache
-                    imageCache.delete(url);
-                    localPath = undefined;
-                }
-            }
-            if (!localPath) {
-                // Download image
-                logInfo(`Downloading image ${i + 1}/${matches.length}: ${url}`);
-                const response = await fetch(url);
-                if (!response.ok) {
-                    logError(`Failed to download image: ${response.statusText}`);
-                    continue;
-                }
-                const extension = detectImageExtension(url, response.headers.get('content-type'));
-                // Use hash of URL as filename (ensures same URL = same file)
-                const urlHash = hashUrl(url);
-                const filename = `${urlHash}.${extension}`;
-                localPath = join(tempDir, filename);
-                // Use Node.js streams to save the file
-                const fileStream = createWriteStream(localPath);
-                if (response.body) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    await pipeline(response.body, fileStream);
-                }
-                // Cache the downloaded image
-                imageCache.set(url, localPath);
-                logInfo(`Downloaded to: ${localPath}`);
-            }
-            downloadedImages.push({ url, localPath, alt });
-            // Replace URL with local path in markdown
-            processedMarkdown = processedMarkdown.replace(match[0], `![${alt}](${localPath})`);
-        }
-        catch (error) {
-            logError(`Failed to download image ${url}: ${error}`);
-        }
-    }
-    return { processedMarkdown, downloadedImages };
-}
-/**
- * Clean markdown by removing width attributes
- */
-export function cleanMarkdownForClaudeCode(markdown) {
-    if (!markdown) {
-        return markdown;
-    }
-    // Remove {width=600} syntax to keep pure markdown
-    return markdown.replace(/!\[([^\]]*)\]\(([^)]+)\)\{width=\d+\}/g, '![$1]($2)');
-}

package/dist/utils/issue-phase-cli.d.ts

@@ -1,26 +0,0 @@
-import { type EdsgerConfig } from '../types/index.js';
-/** Result shape shared by all four issue-scoped phase functions.
- *  `pending` means the phase had no work to do (e.g. nothing to regenerate);
- *  it's not a failure. */
-interface IssuePhaseResult {
-    status: 'success' | 'error' | 'pending';
-    summary: string;
-}
-/**
- * Run a single-issue phase from the CLI: validate config, register a session,
- * invoke the phase function, log the result, and set the process exit code on
- * failure. Used by `issue-analysis`, `user-stories-analysis`,
- * `test-cases-analysis`, and `technical-design` — all of which share the
- * same `(options, config) => Result` shape and need the same wrapper.
- */
-export declare const runIssuePhaseCli: <TResult extends IssuePhaseResult>(args: {
-    command: string;
-    description: string;
-    issueId: string;
-    verbose?: boolean;
-    execute: (options: {
-        issueId: string;
-        verbose?: boolean;
-    }, config: EdsgerConfig) => Promise<TResult>;
-}) => Promise<void>;
-export {};

package/dist/utils/issue-phase-cli.js

@@ -1,44 +0,0 @@
-import { deregisterSession, registerSession, } from '../system/session-manager.js';
-import { logError, logInfo } from './logger.js';
-import { validateConfiguration } from './validation.js';
-/**
- * Run a single-issue phase from the CLI: validate config, register a session,
- * invoke the phase function, log the result, and set the process exit code on
- * failure. Used by `issue-analysis`, `user-stories-analysis`,
- * `test-cases-analysis`, and `technical-design` — all of which share the
- * same `(options, config) => Result` shape and need the same wrapper.
- */
-export const runIssuePhaseCli = async (args) => {
-    const { command, description, issueId, verbose, execute } = args;
-    if (!issueId) {
-        throw new Error(`Issue ID is required for ${command}`);
-    }
-    const config = validateConfiguration({ verbose });
-    // registerSession must run inside the try so a partial failure still
-    // triggers deregisterSession in the finally — otherwise the server-side
-    // session row is leaked.
-    let registered = false;
-    try {
-        await registerSession({ command });
-        registered = true;
-        logInfo(`Starting ${description} for issue: ${issueId}`);
-        const result = await execute({ issueId, verbose }, config);
-        if (result.status === 'error') {
-            logError(`${description} failed: ${result.summary}`);
-            process.exitCode = 1;
-        }
-        else {
-            // success or pending — both are non-failure outcomes
-            logInfo(result.summary);
-        }
-    }
-    catch (error) {
-        logError(`${description} failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exitCode = 1;
-    }
-    finally {
-        if (registered) {
-            await deregisterSession();
-        }
-    }
-};

package/dist/utils/json-extract.d.ts

@@ -1,6 +0,0 @@
-/**
- * Scan a string for the first balanced, top-level JSON object and return its
- * substring. Handles strings with escaped quotes and nested braces. Returns
- * null if no balanced object is present.
- */
-export declare function findBalancedJsonObject(text: string): string | null;

package/dist/utils/json-extract.js

@@ -1,44 +0,0 @@
-/**
- * Scan a string for the first balanced, top-level JSON object and return its
- * substring. Handles strings with escaped quotes and nested braces. Returns
- * null if no balanced object is present.
- */
-export function findBalancedJsonObject(text) {
-    const start = text.indexOf('{');
-    if (start === -1) {
-        return null;
-    }
-    let depth = 0;
-    let inString = false;
-    let escaped = false;
-    for (let i = start; i < text.length; i++) {
-        const ch = text[i];
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (inString) {
-            if (ch === '\\') {
-                escaped = true;
-            }
-            else if (ch === '"') {
-                inString = false;
-            }
-            continue;
-        }
-        if (ch === '"') {
-            inString = true;
-            continue;
-        }
-        if (ch === '{') {
-            depth++;
-        }
-        else if (ch === '}') {
-            depth--;
-            if (depth === 0) {
-                return text.slice(start, i + 1);
-            }
-        }
-    }
-    return null;
-}

package/dist/utils/json-extractor.d.ts

@@ -1,27 +0,0 @@
-/**
- * Shared utilities for extracting JSON from agent response text.
- *
- * Many agent phases return JSON embedded in markdown code blocks or mixed
- * with other text. These helpers provide robust multi-strategy extraction.
- */
-/**
- * Find the start index of a JSON object containing the target key.
- * Searches backwards from the key position to find the opening brace.
- */
-export declare function findJsonStartIndex(text: string, targetKey: string): number;
-/**
- * Find the matching closing brace for a JSON object starting at startIndex.
- * Handles nested braces and string escaping correctly.
- */
-export declare function findMatchingCloseBrace(text: string, startIndex: number): number;
-/**
- * Extract a JSON object from response text using multiple strategies:
- * 1. Markdown code block (```json ... ```)
- * 2. Find JSON object containing a specific key
- * 3. Parse entire response as JSON
- *
- * @param responseText - The raw response text
- * @param targetKey - Key to search for (e.g., '"verification_result"')
- * @returns Parsed JSON object or null
- */
-export declare function extractJsonFromResponse(responseText: string, targetKey: string): Record<string, unknown> | null;

package/dist/utils/json-extractor.js

@@ -1,102 +0,0 @@
-/**
- * Shared utilities for extracting JSON from agent response text.
- *
- * Many agent phases return JSON embedded in markdown code blocks or mixed
- * with other text. These helpers provide robust multi-strategy extraction.
- */
-/**
- * Find the start index of a JSON object containing the target key.
- * Searches backwards from the key position to find the opening brace.
- */
-export function findJsonStartIndex(text, targetKey) {
-    if (!text.includes(targetKey)) {
-        return -1;
-    }
-    const targetIndex = text.indexOf(targetKey);
-    for (let i = targetIndex; i >= 0; i--) {
-        if (text[i] === '{') {
-            return i;
-        }
-    }
-    return -1;
-}
-/**
- * Find the matching closing brace for a JSON object starting at startIndex.
- * Handles nested braces and string escaping correctly.
- */
-export function findMatchingCloseBrace(text, startIndex) {
-    let braceCount = 0;
-    let endIndex = startIndex;
-    let inString = false;
-    let escapeNext = false;
-    for (let i = startIndex; i < text.length; i++) {
-        const char = text[i];
-        if (escapeNext) {
-            escapeNext = false;
-            continue;
-        }
-        if (char === '\\' && inString) {
-            escapeNext = true;
-            continue;
-        }
-        if (char === '"') {
-            inString = !inString;
-            continue;
-        }
-        if (inString) {
-            continue;
-        }
-        if (char === '{') {
-            braceCount++;
-        }
-        else if (char === '}') {
-            braceCount--;
-            if (braceCount === 0) {
-                endIndex = i;
-                break;
-            }
-        }
-    }
-    return endIndex;
-}
-/**
- * Extract a JSON object from response text using multiple strategies:
- * 1. Markdown code block (```json ... ```)
- * 2. Find JSON object containing a specific key
- * 3. Parse entire response as JSON
- *
- * @param responseText - The raw response text
- * @param targetKey - Key to search for (e.g., '"verification_result"')
- * @returns Parsed JSON object or null
- */
-export function extractJsonFromResponse(responseText, targetKey) {
-    // Strategy 1: markdown code block
-    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-    if (jsonBlockMatch) {
-        try {
-            return JSON.parse(jsonBlockMatch[1]);
-        }
-        catch {
-            // Fall through to other strategies
-        }
-    }
-    // Strategy 2: find JSON object by target key
-    const jsonStartIndex = findJsonStartIndex(responseText, targetKey);
-    if (jsonStartIndex !== -1) {
-        const endIndex = findMatchingCloseBrace(responseText, jsonStartIndex);
-        const jsonStr = responseText.substring(jsonStartIndex, endIndex + 1);
-        try {
-            return JSON.parse(jsonStr);
-        }
-        catch {
-            // Fall through to strategy 3
-        }
-    }
-    // Strategy 3: parse entire response
-    try {
-        return JSON.parse(responseText);
-    }
-    catch {
-        return null;
-    }
-}

package/dist/utils/logger.d.ts

@@ -1,35 +0,0 @@
-import { type ReviewResult } from '../types/index.js';
-export declare const colors: {
-    reset: string;
-    bright: string;
-    red: string;
-    green: string;
-    yellow: string;
-    blue: string;
-    magenta: string;
-    cyan: string;
-    gray: string;
-};
-export declare const colorize: (text: string, color: keyof typeof colors) => string;
-/**
- * Flush buffered logs to the server. Best-effort, failures are silent.
- */
-export declare function flushLogs(): Promise<void>;
-/**
- * Start log sync for a CLI session. Call after session registration.
- */
-export declare function initLogSync(sessionId: string): void;
-/**
- * Stop log sync and flush remaining logs. Call before session deregistration.
- */
-export declare function stopLogSync(): Promise<void>;
-export declare const logInfo: (message: string) => void;
-export declare const logSuccess: (message: string) => void;
-export declare const logWarning: (message: string) => void;
-export declare const logError: (message: string) => void;
-/** Verbose-only debug logging. Only outputs when verbose is true. */
-export declare const logDebug: (message: string, verbose?: boolean) => void;
-/** Raw output without version prefix. For streaming AI responses, formatting, etc. */
-export declare const logRaw: (message: string) => void;
-export declare const logProgress: (current: number, total: number, file: string) => void;
-export declare const logResults: (results: ReviewResult[], verbose?: boolean) => void;