edsger 0.77.0 → 0.78.0

package/dist/phases/flow-shared/clone-repos.d.ts

@@ -1,63 +0,0 @@
-/**
- * Shared multi-repo cloning for flow generation (screen-flow / data-flow).
- *
- * A flow can be scoped to one or several repositories (the user picks them in
- * the desktop UI; the chosen set is stored on `flows.repository_ids`). This
- * helper resolves that set, clones each repo into a per-flow parent workspace
- * directory, and returns the directory the agent should run against:
- *   - single repo  → the repo's own clone dir
- *   - many repos   → the parent dir holding every clone as a subdirectory,
- *                    so the agent can explore them all and produce one unified
- *                    flow.
- *
- * Falls back to the product's primary repo when `repository_ids` is empty
- * (older flows, or single-repo products).
- */
-export interface ClonedRepo {
-    fullName: string;
-    owner: string;
-    repo: string;
-    dir: string;
-}
-export interface CloneFlowReposSuccess {
-    ok: true;
-    /** Directory to point the agent at (parent dir for multi-repo). */
-    projectDir: string;
-    /** Directory to clean up afterwards (always the per-flow parent). */
-    cleanupDir: string;
-    repos: ClonedRepo[];
-}
-export interface CloneFlowReposFailure {
-    ok: false;
-    message: string;
-}
-export declare function safeDirName(fullName: string): string;
-/**
- * Resolve the repositories a flow targets (by id, preserving the stored
- * order), falling back to the product's primary repo.
- *
- * In repo-only mode there is no product, so no `fallback` is provided: the
- * set is resolved purely from `repositoryIds`.
- */
-export declare function resolveTargetRepos(productId: string | undefined, repositoryIds: string[], fallback?: {
-    owner: string;
-    repo: string;
-}): Promise<{
-    fullName: string;
-    owner: string;
-    repo: string;
-}[]>;
-export declare function cloneFlowRepos(opts: {
-    /** Product-scoped flow. Mutually exclusive with `repoId`. */
-    productId?: string;
-    /** Repo-only flow: a single repositories row, no product context. */
-    repoId?: string;
-    repositoryIds: string[];
-    workspaceKey: string;
-    verbose?: boolean;
-}): Promise<CloneFlowReposSuccess | CloneFlowReposFailure>;
-/**
- * Build a short note describing the repo scope, appended to the agent's user
- * prompt so it knows whether to map one repo or unify several.
- */
-export declare function describeRepoScope(repos: ClonedRepo[]): string;

package/dist/phases/flow-shared/clone-repos.js

@@ -1,153 +0,0 @@
-/**
- * Shared multi-repo cloning for flow generation (screen-flow / data-flow).
- *
- * A flow can be scoped to one or several repositories (the user picks them in
- * the desktop UI; the chosen set is stored on `flows.repository_ids`). This
- * helper resolves that set, clones each repo into a per-flow parent workspace
- * directory, and returns the directory the agent should run against:
- *   - single repo  → the repo's own clone dir
- *   - many repos   → the parent dir holding every clone as a subdirectory,
- *                    so the agent can explore them all and produce one unified
- *                    flow.
- *
- * Falls back to the product's primary repo when `repository_ids` is empty
- * (older flows, or single-repo products).
- */
-import { getGitHubConfigByProduct, getGitHubConfigByRepository, } from '../../api/github.js';
-import { getSupabase } from '../../supabase/client.js';
-import { logInfo, logWarning } from '../../utils/logger.js';
-import { cloneIssueRepo, ensureWorkspaceDir, getIssueRepoPath, } from '../../workspace/workspace-manager.js';
-export function safeDirName(fullName) {
-    return fullName.replace(/[^a-zA-Z0-9._-]/g, '_');
-}
-/**
- * Resolve the repositories a flow targets (by id, preserving the stored
- * order), falling back to the product's primary repo.
- *
- * In repo-only mode there is no product, so no `fallback` is provided: the
- * set is resolved purely from `repositoryIds`.
- */
-export async function resolveTargetRepos(productId, repositoryIds, fallback) {
-    if (repositoryIds.length === 0) {
-        if (fallback) {
-            return [
-                {
-                    fullName: `${fallback.owner}/${fallback.repo}`,
-                    owner: fallback.owner,
-                    repo: fallback.repo,
-                },
-            ];
-        }
-        return [];
-    }
-    const supabase = getSupabase();
-    const { data } = await supabase
-        .from('repositories')
-        .select('id, full_name')
-        .in('id', repositoryIds);
-    const byId = new Map((data ?? []).map((r) => [r.id, r.full_name]));
-    // Preserve the caller's order (flows.repository_ids is ordered).
-    const resolved = [];
-    for (const id of repositoryIds) {
-        const fullName = byId.get(id);
-        if (!fullName) {
-            continue;
-        }
-        const [owner, repo] = fullName.split('/');
-        if (!owner || !repo) {
-            continue;
-        }
-        resolved.push({ fullName, owner, repo });
-    }
-    // If none resolved (deleted repos / RLS), fall back to the primary repo so
-    // generation still produces something useful (product mode only).
-    if (resolved.length === 0 && fallback) {
-        return [
-            {
-                fullName: `${fallback.owner}/${fallback.repo}`,
-                owner: fallback.owner,
-                repo: fallback.repo,
-            },
-        ];
-    }
-    return resolved;
-}
-export async function cloneFlowRepos(opts) {
-    const { productId, repoId, repositoryIds, workspaceKey, verbose } = opts;
-    const repoOnly = !productId && Boolean(repoId);
-    // Resolve the auth token. Product mode reuses the product's installation /
-    // PAT for every repo; repo-only mode resolves it from the first (only) repo.
-    const gh = repoOnly
-        ? await getGitHubConfigByRepository(repositoryIds[0] ?? repoId, verbose)
-        : await getGitHubConfigByProduct(productId, verbose);
-    if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
-        return {
-            ok: false,
-            message: gh.message ||
-                (repoOnly
-                    ? 'GitHub repository not configured. Connect the repo first.'
-                    : 'GitHub repository not configured for this product. Connect a repo first.'),
-        };
-    }
-    // In repo-only mode there is no product primary-repo fallback; targets come
-    // purely from repositoryIds.
-    const targets = await resolveTargetRepos(productId, repositoryIds, repoOnly ? undefined : { owner: gh.owner, repo: gh.repo });
-    if (targets.length === 0) {
-        return {
-            ok: false,
-            message: 'No repositories resolved for this flow.',
-        };
-    }
-    const workspaceRoot = ensureWorkspaceDir();
-    const parentDir = getIssueRepoPath(workspaceRoot, `${workspaceKey}-${repoOnly ? `repo-${repoId}` : productId}`);
-    const repos = [];
-    for (const target of targets) {
-        try {
-            // The product-level token (installation or user PAT/OAuth) is reused for
-            // every repo; if it can't access one, that clone fails and we skip it
-            // rather than aborting the whole generation.
-            const { repoPath } = cloneIssueRepo(parentDir, safeDirName(target.fullName), target.owner, target.repo, gh.token);
-            repos.push({
-                fullName: target.fullName,
-                owner: target.owner,
-                repo: target.repo,
-                dir: repoPath,
-            });
-        }
-        catch (err) {
-            logWarning(`Skipping ${target.fullName}: clone failed (${err instanceof Error ? err.message : String(err)})`);
-        }
-    }
-    if (repos.length === 0) {
-        return {
-            ok: false,
-            message: 'Failed to clone any of the selected repositories.',
-        };
-    }
-    if (repos.length > 1) {
-        logInfo(`Cloned ${repos.length} repos for ${workspaceKey}: ${repos.map((r) => r.fullName).join(', ')}`);
-    }
-    return {
-        ok: true,
-        // Single repo: run directly in its dir. Multi-repo: run in the parent so
-        // the agent sees every clone as a subdirectory.
-        projectDir: repos.length === 1 ? repos[0].dir : parentDir,
-        cleanupDir: parentDir,
-        repos,
-    };
-}
-/**
- * Build a short note describing the repo scope, appended to the agent's user
- * prompt so it knows whether to map one repo or unify several.
- */
-export function describeRepoScope(repos) {
-    if (repos.length <= 1) {
-        return '';
-    }
-    const list = repos.map((r) => `- ${r.fullName} (subdirectory: ${safeDirName(r.fullName)})`);
-    return [
-        `This product spans ${repos.length} repositories, each cloned into its own subdirectory of the working directory:`,
-        ...list,
-        'Explore all of them and produce a single unified flow that spans the repositories.',
-    ].join('\n');
-}

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

@@ -1,15 +0,0 @@
-/**
- * flowchart phase: map the control flow of one process / function / algorithm
- * as a flowchart — start/end, process steps, decisions (with branch labels),
- * I/O, and subroutine calls. Persisted to the diagrams tables with
- * `type = 'flowchart'`.
- */
-import { type DiagramPhaseResult } from '../diagram-shared/generate.js';
-export interface FlowchartPhaseOptions {
-    productId?: string;
-    repoId?: string;
-    diagramId: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export declare function runFlowchartPhase(options: FlowchartPhaseOptions): Promise<DiagramPhaseResult>;

package/dist/phases/flowchart/index.js

@@ -1,50 +0,0 @@
-/**
- * flowchart phase: map the control flow of one process / function / algorithm
- * as a flowchart — start/end, process steps, decisions (with branch labels),
- * I/O, and subroutine calls. Persisted to the diagrams tables with
- * `type = 'flowchart'`.
- */
-import { z } from 'zod';
-import { generateDiagram, } from '../diagram-shared/generate.js';
-import { buildDiagramSystemPrompt, buildDiagramUserPrompt, } from '../diagram-shared/prompts.js';
-const flowchartNode = z.object({
-    slug: z.string().min(1),
-    name: z.string().min(1),
-    kind: z.enum(['start', 'end', 'process', 'decision', 'io', 'subroutine']),
-    file: z.string().optional(),
-    description: z.string().optional(),
-});
-const flowchartEdge = z.object({
-    fromSlug: z.string().min(1),
-    toSlug: z.string().min(1),
-    kind: z.enum(['flow', 'branch']),
-    /** Branch label for edges out of a decision, e.g. "yes" / "no" / "error". */
-    label: z.string().optional(),
-    sourceFile: z.string().optional(),
-});
-export function runFlowchartPhase(options) {
-    return generateDiagram({
-        ...options,
-        workspaceKey: 'flowchart',
-        fenceName: 'flowchart',
-        nounPlural: 'steps',
-        edgeNounPlural: 'arrows',
-        mcpConfig: {
-            name: 'flowchart',
-            toolName: 'flowchart',
-            summaryDescribe: '1-3 sentence narrative of the process this flowchart captures.',
-            nodesSchema: z.array(flowchartNode),
-            nodesDescribe: 'Every step: start / end / process / decision / io / subroutine. slug MUST be unique. Use exactly one `start`.',
-            edgesSchema: z.array(flowchartEdge),
-            edgesDescribe: 'Arrows. kind = flow (plain) or branch (out of a decision; set label to the branch condition like "yes"/"no"). Endpoints MUST reference emitted steps.',
-        },
-        buildSystemPrompt: (a) => buildDiagramSystemPrompt('phase/flowchart', 'flowchart', a),
-        buildUserPrompt: (a) => buildDiagramUserPrompt({
-            ...a,
-            task: 'Map a flowchart for',
-            mcpName: 'flowchart',
-            toolName: 'flowchart',
-            process: 'Pick ONE important process / function / algorithm (guidance may name it; otherwise choose a central one — a request handler, a core algorithm, a job). Read it top to bottom and translate its control flow into steps: a single `start`, `process` steps for actions, `decision` diamonds for branches (each outgoing edge a `branch` with a "yes"/"no"/condition label), `io` for reads/writes, `subroutine` for significant calls, and `end` node(s) for returns/exits. Follow the happy path plus the important branches.',
-        }),
-    });
-}

package/dist/phases/functional-testing/analyzer.d.ts

@@ -1,46 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type TestReportResult } from './test-report-creator.js';
-export interface FunctionalTestingOptions {
-    issueId: string;
-    verbose?: boolean;
-}
-export interface StructuredTestResult {
-    status: 'testing_passed' | 'testing_failed';
-    title: string;
-    summary: string;
-    total_test_cases: number;
-    passed_test_cases: number;
-    failed_test_cases: number;
-    test_cases?: {
-        name: string;
-        status: 'passed' | 'failed' | 'skipped';
-        description?: string;
-        error_message?: string;
-    }[];
-    execution_details?: string;
-    timestamp: string;
-    checklist_item_results?: {
-        checklist_item_id: string;
-        is_passed: boolean;
-        value?: unknown;
-        notes?: string;
-    }[];
-}
-export interface FunctionalTestingResult {
-    issueId: string;
-    testStatus: 'testing_passed' | 'testing_failed';
-    structuredTestResult: StructuredTestResult | null;
-    testReport?: TestReportResult;
-    status: 'success' | 'error';
-    message: string;
-    data?: {
-        checklist_item_results?: {
-            checklist_item_id: string;
-            is_passed: boolean;
-            value?: unknown;
-            notes?: string;
-        }[];
-    };
-}
-export declare const runFunctionalTesting: (options: FunctionalTestingOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<FunctionalTestingResult>;