edsger 0.76.0 → 0.78.0

package/dist/phases/find-shared/git.js

@@ -1,60 +0,0 @@
-/**
- * Git helpers shared by the find-* phases (find-bugs, find-features,
- * find-smells). All three clone a product's repo, sync to a branch, and need
- * the same low-level rev/diff queries — keep them here so behaviour stays in
- * lock-step.
- *
- * Read-only on the working tree; safe to call against any cwd that is a git
- * repo.
- */
-import { execFileSync } from 'child_process';
-export function gitRevParse(repoPath, ref) {
-    return execFileSync('git', ['rev-parse', ref], {
-        cwd: repoPath,
-        encoding: 'utf-8',
-    }).trim();
-}
-/**
- * Resolve the remote's default branch (e.g. "main", "master", "trunk") via the
- * symbolic ref `refs/remotes/origin/HEAD`. Falls back to "main" if the ref is
- * missing — the caller will surface a sync error if that's wrong.
- */
-export function detectDefaultBranch(repoPath) {
-    try {
-        const ref = execFileSync('git', ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], { cwd: repoPath, encoding: 'utf-8' }).trim();
-        return ref.replace(/^origin\//, '');
-    }
-    catch {
-        return 'main';
-    }
-}
-/**
- * True iff `ancestor` is reachable from `descendant` (i.e. `descendant`
- * contains all of `ancestor`'s history). Used by incremental scans to decide
- * whether a previously-scanned commit is still part of HEAD's history before
- * trusting a `git diff base..head`.
- */
-export function isAncestor(repoPath, ancestor, descendant) {
-    try {
-        execFileSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
-            cwd: repoPath,
-            stdio: 'pipe',
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function listChangedPaths(repoPath, baseSha, headSha) {
-    try {
-        const out = execFileSync('git', ['diff', '--name-only', `${baseSha}..${headSha}`], { cwd: repoPath, encoding: 'utf-8' });
-        return out
-            .split('\n')
-            .map((s) => s.trim())
-            .filter((s) => s.length > 0);
-    }
-    catch {
-        return [];
-    }
-}

package/dist/phases/find-shared/mcp.d.ts

@@ -1,48 +0,0 @@
-/**
- * MCP helpers shared by find-bugs / find-features / find-smells.
- *
- * All three load a product's basics (name, description) for prompt context,
- * pull the open-issue list for dedup, and file findings via `issues/create`.
- * Centralising the calls means a schema change in MCP only needs touching one
- * place, and the per-phase orchestrators stay focused on their own logic.
- */
-import { type IssueInfo } from '../../types/issues.js';
-export interface ProductBasics {
-    name: string;
-    description?: string;
-}
-export declare function fetchProductBasics(productId: string): Promise<ProductBasics>;
-/**
- * Build prompt "product basics" from a bare repository row (repo-scoped scans
- * have no product to read). Falls back to the repo id as the display name.
- */
-export declare function fetchRepositoryBasics(repoId: string): Promise<ProductBasics>;
-/**
- * Fetch the product's open issues for dedup context. Filters out terminal
- * statuses (shipped/archived/closed/...) since those can't conflict with new
- * findings the agent might surface.
- */
-export declare function fetchOpenIssues(productId: string): Promise<IssueInfo[]>;
-/**
- * Same as `fetchOpenIssues` but scoped to a single repository (repo-scoped
- * scans). Used for dedup context when filing findings against a bare repo.
- */
-export declare function fetchOpenIssuesByRepo(repoId: string): Promise<IssueInfo[]>;
-export declare function isTerminalStatus(status: string): boolean;
-export interface CreateIssueInput {
-    /** Product scope. Provide this OR repoId (repo-scoped scans). */
-    productId?: string;
-    /** Repository scope. Provide this OR productId. */
-    repoId?: string;
-    /** Issue title for `name`. */
-    title: string;
-    /** Already-formatted markdown body. The caller decides the layout. */
-    description: string;
-}
-/**
- * File a new issue via MCP. The issue is scoped to a product OR a single
- * repository — exactly one of `productId` / `repoId` should be set. Returns the
- * new issue id, or null if MCP returned an error / unexpected shape (already
- * logged).
- */
-export declare function createIssue(input: CreateIssueInput): Promise<string | null>;

package/dist/phases/find-shared/mcp.js

@@ -1,125 +0,0 @@
-/**
- * MCP helpers shared by find-bugs / find-features / find-smells.
- *
- * All three load a product's basics (name, description) for prompt context,
- * pull the open-issue list for dedup, and file findings via `issues/create`.
- * Centralising the calls means a schema change in MCP only needs touching one
- * place, and the per-phase orchestrators stay focused on their own logic.
- */
-import { getRepositoryBasics } from '../../api/github.js';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
-import { logError, logWarning } from '../../utils/logger.js';
-export async function fetchProductBasics(productId) {
-    try {
-        const result = (await callMcpEndpoint('resources/read', {
-            uri: `product://${productId}`,
-        }));
-        const text = result.contents?.[0]?.text || '{}';
-        const parsed = JSON.parse(text);
-        return {
-            name: parsed.name || productId,
-            description: parsed.description,
-        };
-    }
-    catch {
-        return { name: productId };
-    }
-}
-/**
- * Build prompt "product basics" from a bare repository row (repo-scoped scans
- * have no product to read). Falls back to the repo id as the display name.
- */
-export async function fetchRepositoryBasics(repoId) {
-    const basics = await getRepositoryBasics(repoId).catch(() => null);
-    return {
-        name: basics?.fullName || repoId,
-        description: basics?.description ?? undefined,
-    };
-}
-/**
- * Fetch the product's open issues for dedup context. Filters out terminal
- * statuses (shipped/archived/closed/...) since those can't conflict with new
- * findings the agent might surface.
- */
-export async function fetchOpenIssues(productId) {
-    try {
-        const result = (await callMcpEndpoint('issues/list', {
-            product_id: productId,
-        }));
-        const all = result.issues || [];
-        return all.filter((i) => !isTerminalStatus(i.status));
-    }
-    catch (error) {
-        logWarning(`Could not load existing issues for dedup: ${error instanceof Error ? error.message : String(error)}`);
-        return [];
-    }
-}
-/**
- * Same as `fetchOpenIssues` but scoped to a single repository (repo-scoped
- * scans). Used for dedup context when filing findings against a bare repo.
- */
-export async function fetchOpenIssuesByRepo(repoId) {
-    try {
-        const result = (await callMcpEndpoint('issues/list', {
-            repository_id: repoId,
-        }));
-        const all = result.issues || [];
-        return all.filter((i) => !isTerminalStatus(i.status));
-    }
-    catch (error) {
-        logWarning(`Could not load existing issues for dedup: ${error instanceof Error ? error.message : String(error)}`);
-        return [];
-    }
-}
-export function isTerminalStatus(status) {
-    return (status === 'shipped' ||
-        status === 'archived' ||
-        status === 'cancelled' ||
-        status === 'closed' ||
-        status === 'completed');
-}
-/**
- * File a new issue via MCP. The issue is scoped to a product OR a single
- * repository — exactly one of `productId` / `repoId` should be set. Returns the
- * new issue id, or null if MCP returned an error / unexpected shape (already
- * logged).
- */
-export async function createIssue(input) {
-    const productId = input.productId ?? null;
-    const repositoryId = input.repoId ?? null;
-    try {
-        if (hasSupabaseSession()) {
-            try {
-                const { data, error } = await getSupabase()
-                    .from('issues')
-                    .insert({
-                    product_id: productId,
-                    repository_id: repositoryId,
-                    name: input.title,
-                    description: input.description,
-                })
-                    .select('id')
-                    .single();
-                if (error) {
-                    throw new Error(error.message);
-                }
-                return data?.id || null;
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        const result = (await callMcpEndpoint('issues/create', {
-            ...(productId ? { product_id: productId } : {}),
-            ...(repositoryId ? { repository_id: repositoryId } : {}),
-            name: input.title,
-            description: input.description,
-        }));
-        return result.issue?.id || result.id || null;
-    }
-    catch (error) {
-        logError(`Failed to create issue for "${input.title}": ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}

package/dist/phases/find-shared/scan-state.d.ts

@@ -1,33 +0,0 @@
-/**
- * Per-product scan state, generic across the find-* phases. Each phase has
- * its own state schema (find-bugs tracks a commit sha, find-features tracks
- * the most-recent-seen feedback id, etc.) so the type is parametric, but the
- * file layout, atomic-write, and lock semantics are identical and live here.
- *
- * Storage layout: `~/.edsger/<dirName>/<productId>.json` plus a sibling
- * `.lock` file. The lockfile uses O_EXCL so concurrent acquirers race on the
- * filesystem, not on application code — atomic on local POSIX filesystems
- * (good enough; the workspace clone is also machine-local).
- *
- * Known limitation: state is machine-local. A scan started on machine A and
- * next on machine B will look like a first run.
- */
-export interface LockHandle {
-    release: () => void;
-}
-export interface ScanStateModule<T extends object> {
-    load: (productId: string) => T;
-    save: (productId: string, state: T) => void;
-    /** Merge `patch` into the stored state. Fields not mentioned are preserved. */
-    update: (productId: string, patch: Partial<T>) => T;
-    /**
-     * Acquire an exclusive lock for this product's state. Returns null if held.
-     * Stale locks older than `staleAfterMs` (default 1h) are reclaimed.
-     */
-    acquireLock: (productId: string, staleAfterMs?: number) => LockHandle | null;
-}
-export interface CreateScanStateModuleOptions {
-    /** Subdirectory under ~/.edsger/. Example: 'find-bugs-state'. */
-    dirName: string;
-}
-export declare function createScanStateModule<T extends object>(opts: CreateScanStateModuleOptions): ScanStateModule<T>;

package/dist/phases/find-shared/scan-state.js

@@ -1,112 +0,0 @@
-/**
- * Per-product scan state, generic across the find-* phases. Each phase has
- * its own state schema (find-bugs tracks a commit sha, find-features tracks
- * the most-recent-seen feedback id, etc.) so the type is parametric, but the
- * file layout, atomic-write, and lock semantics are identical and live here.
- *
- * Storage layout: `~/.edsger/<dirName>/<productId>.json` plus a sibling
- * `.lock` file. The lockfile uses O_EXCL so concurrent acquirers race on the
- * filesystem, not on application code — atomic on local POSIX filesystems
- * (good enough; the workspace clone is also machine-local).
- *
- * Known limitation: state is machine-local. A scan started on machine A and
- * next on machine B will look like a first run.
- */
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-const DEFAULT_STALE_AFTER_MS = 60 * 60 * 1000;
-export function createScanStateModule(opts) {
-    const { dirName } = opts;
-    // Resolve at call time, not module-load time, so test setups that swap
-    // process.env.HOME between cases see the change.
-    function stateDir() {
-        return join(homedir(), '.edsger', dirName);
-    }
-    function safeProductId(productId) {
-        return productId.replace(/[^a-zA-Z0-9_-]/g, '_');
-    }
-    function statePath(productId) {
-        return join(stateDir(), `${safeProductId(productId)}.json`);
-    }
-    function lockPath(productId) {
-        return join(stateDir(), `${safeProductId(productId)}.lock`);
-    }
-    function ensureStateDir() {
-        const dir = stateDir();
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-    }
-    function load(productId) {
-        const p = statePath(productId);
-        if (!existsSync(p)) {
-            return {};
-        }
-        try {
-            const raw = readFileSync(p, 'utf-8');
-            const parsed = JSON.parse(raw);
-            return parsed && typeof parsed === 'object' ? parsed : {};
-        }
-        catch {
-            return {};
-        }
-    }
-    /** Atomic write: stage to a tempfile, then rename. */
-    function save(productId, state) {
-        ensureStateDir();
-        const finalPath = statePath(productId);
-        const tmpPath = `${finalPath}.${process.pid}.tmp`;
-        writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf-8');
-        renameSync(tmpPath, finalPath);
-    }
-    function update(productId, patch) {
-        const merged = { ...load(productId), ...patch };
-        save(productId, merged);
-        return merged;
-    }
-    function acquireLock(productId, staleAfterMs = DEFAULT_STALE_AFTER_MS) {
-        ensureStateDir();
-        const lock = lockPath(productId);
-        if (existsSync(lock)) {
-            try {
-                const raw = readFileSync(lock, 'utf-8');
-                const parsed = JSON.parse(raw);
-                const age = Date.now() - new Date(parsed.acquiredAt ?? 0).getTime();
-                if (age < staleAfterMs) {
-                    return null;
-                }
-                // Stale or corrupt — reclaim. Only reachable if a previous run died
-                // without releasing (SIGKILL, OOM).
-                rmSync(lock, { force: true });
-            }
-            catch {
-                rmSync(lock, { force: true });
-            }
-        }
-        try {
-            // `flag: 'wx'` = open with O_CREAT | O_EXCL — atomic against a racing
-            // peer, and writeFileSync(path, ...) closes the fd internally so no
-            // manual closeSync is needed (vs. the openSync + writeFileSync(fd)
-            // form, which leaks the fd).
-            writeFileSync(lock, JSON.stringify({
-                acquiredAt: new Date().toISOString(),
-                pid: process.pid,
-            }), { flag: 'wx' });
-            return {
-                release: () => {
-                    try {
-                        unlinkSync(lock);
-                    }
-                    catch {
-                        // Already gone — fine.
-                    }
-                },
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    return { load, save, update, acquireLock };
-}

package/dist/phases/find-smells/index.d.ts

@@ -1,50 +0,0 @@
-/**
- * Find-smells phase: clone the product's repo, ask Claude to audit code for
- * code smells (refactor candidates, perf cliffs, dead code, etc.), and file
- * each new finding as an issue. Subsequent runs are incremental, scoped to
- * commits since the previous successful scan.
- *
- * Companion to find-bugs (real defects) and find-features (missing user
- * capability). The three phases share the same workspace + state pattern.
- */
-import { type SmellCategory } from './types.js';
-export interface FindSmellsOptions {
-    /** Product scope. Provide this OR repoId (repo-scoped scan). */
-    productId?: string;
-    /** Repository scope: scan a bare `repositories` row with no product. */
-    repoId?: string;
-    githubToken: string;
-    owner: string;
-    repo: string;
-    /** Force a full scan even if previous-scan state exists. */
-    full?: boolean;
-    /** Branch to scan; defaults to the repo's default branch. */
-    branch?: string;
-    /** Upper bound on files the auditor may Read. Keeps token cost predictable. */
-    maxFiles?: number;
-    /**
-     * Optional category filter. Agent is asked to honour it via the prompt
-     * AND its output is re-filtered after parsing — both are required because
-     * the agent can't be trusted to obey perfectly.
-     */
-    categories?: SmellCategory[];
-    verbose?: boolean;
-}
-export interface FindSmellsResult {
-    status: 'success' | 'error';
-    message: string;
-    scannedCommitSha?: string;
-    smellsFound?: number;
-    issuesCreated?: number;
-    /** Findings the agent passed off to find-bugs (not filed by this run). */
-    deferredToBugs?: number;
-    /** Findings the agent passed off to find-features (not filed by this run). */
-    deferredToFeatures?: number;
-    summary?: string;
-}
-/** Single source of truth — referenced by the CLI help string too. */
-export declare const DEFAULT_MAX_FILES = 200;
-/**
- * Scan a product's repository for code smells and file each new finding as an issue.
- */
-export declare function scanForSmells(options: FindSmellsOptions): Promise<FindSmellsResult>;