edsger 0.76.0 → 0.78.0

package/dist/workspace/session-workspace.js

@@ -1,90 +0,0 @@
-/**
- * Session workspace — clones a product's configured repositories into a single
- * local "session directory", one subdirectory per repo.
- *
- * A chat session (an `ai_assistant` channel) is bound to a product, and a
- * product can span several repositories. For the session agent's read-only
- * tools (Read / Grep / Glob) to inspect the real code, we clone every in-scope
- * repo into:
- *
- *   <workspace>/sessions/<channelId>/<owner>_<repo>/
- *
- * and point the agent's cwd at the per-session directory. The clones are reused
- * (and fetched) across turns of the same session rather than re-cloned each
- * time, so follow-up turns are fast and always see the latest code.
- *
- * Repo resolution and the secure-token clone are shared with flow generation
- * (`phases/diagram-shared/clone-repos.ts`).
- */
-import { mkdirSync } from 'fs';
-import { getGitHubConfigByProduct } from '../api/github.js';
-import { resolveTargetRepos, safeDirName, } from '../phases/diagram-shared/clone-repos.js';
-import { logInfo, logWarning } from '../utils/logger.js';
-import { cloneIssueRepo, ensureWorkspaceDir, getIssueRepoPath, } from './workspace-manager.js';
-const SESSIONS_DIR_NAME = 'sessions';
-/**
- * Clone (or refresh) every repository the session's product is scoped to into a
- * single local session directory. Returns the directory to use as the agent's
- * cwd plus the cloned repos, or `null` when no repo could be made available
- * (no GitHub config, or every clone failed) so the caller can still run the
- * agent without a codebase.
- */
-export async function cloneSessionRepos(opts) {
-    const { channelId, productId, repositoryIds, verbose } = opts;
-    const gh = await getGitHubConfigByProduct(productId, verbose);
-    if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
-        logWarning(gh.message ||
-            'No GitHub repository configured for this product; the session agent will run without a codebase.');
-        return null;
-    }
-    // Resolve the in-scope repos (ordered), falling back to the product's
-    // primary repo when none were explicitly selected.
-    const targets = await resolveTargetRepos(productId, repositoryIds, {
-        owner: gh.owner,
-        repo: gh.repo,
-    });
-    const workspaceRoot = ensureWorkspaceDir();
-    const sessionDir = getIssueRepoPath(workspaceRoot, `${SESSIONS_DIR_NAME}/${safeDirName(channelId)}`);
-    // Ensure the per-session parent exists before cloning into subdirectories.
-    mkdirSync(sessionDir, { recursive: true });
-    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 session.
-            const { repoPath } = cloneIssueRepo(sessionDir, 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 null;
-    }
-    logInfo(`Session ${channelId}: ${repos.length} repo(s) ready in ${sessionDir}`);
-    return { sessionDir, repos };
-}
-/**
- * Build a note for the agent's system prompt describing where each repo is
- * checked out, so it points Read / Grep / Glob at the right subdirectory.
- */
-export function describeSessionRepos(repos) {
-    if (repos.length === 0) {
-        return '';
-    }
-    const list = repos.map((r) => `- ${r.fullName} → subdirectory \`${safeDirName(r.fullName)}/\``);
-    return [
-        repos.length === 1
-            ? 'The product code is checked out in your working directory:'
-            : `This product spans ${repos.length} repositories, each checked out as a subdirectory of your working directory:`,
-        ...list,
-        'Use Read / Grep / Glob against these paths to inspect the actual code before answering.',
-    ].join('\n');
-}

package/dist/workspace/workspace-manager.d.ts

@@ -1,105 +0,0 @@
-/**
- * Workspace Manager - Manages the edsger working directory and issue repos
- *
- * Handles:
- * - Detecting or creating the 'edsger' working directory
- * - Cloning repos using GitHub App installation tokens
- * - Using issue ID as directory name for cloned repos
- * - Reusing existing cloned repos for the same issue
- */
-export interface WorkspaceConfig {
-    /** Root workspace directory path */
-    rootDir: string;
-}
-export interface IssueRepo {
-    /** Path to the cloned repo directory */
-    repoPath: string;
-    /** Whether the repo was freshly cloned (vs reused) */
-    freshClone: boolean;
-}
-/**
- * Determine the workspace root directory.
- *
- * Rules:
- * - If current directory basename is 'edsger', use it as workspace root
- * - Otherwise, create an 'edsger' subdirectory in the current directory
- */
-export declare function getWorkspaceRoot(): string;
-/**
- * Ensure the workspace directory exists
- */
-export declare function ensureWorkspaceDir(): string;
-/**
- * Get the directory path for an issue's repo clone
- * Uses the issue ID as the directory name
- */
-export declare function getIssueRepoPath(workspaceRoot: string, issueId: string): string;
-/**
- * Check if an issue's repo already exists locally
- */
-export declare function issueRepoExists(workspaceRoot: string, issueId: string): boolean;
-/**
- * Clone a repository for an issue using GitHub App installation token
- *
- * Uses `git -c credential.helper` to pass the token securely
- * instead of embedding it in the clone URL (which would be visible via `ps`).
- *
- * @param workspaceRoot - The workspace root directory
- * @param issueId - The issue ID (used as directory name)
- * @param owner - GitHub repo owner
- * @param repo - GitHub repo name
- * @param token - GitHub installation token
- * @returns IssueRepo with the path and clone status
- */
-export declare function cloneIssueRepo(workspaceRoot: string, issueId: string, owner: string, repo: string, token: string): IssueRepo;
-/**
- * Loose validator for a git ref name (tag or branch) coming from callers
- * that pass data originating from external sources (GitHub API, AI output).
- *
- * Rules match `git check-ref-format` plus a length cap. Rejecting bad
- * input early keeps it out of execFileSync argv.
- */
-export declare function isSafeGitRef(ref: string): boolean;
-/**
- * Sync a cloned issue repo to a specific git ref — a tag or a branch.
- *
- * Behaviour:
- * - `git fetch origin --tags --prune` brings in new tags (release tags!) and
- *   drops deleted remote branches, using the installation-token credential
- *   helper so private repos keep working.
- * - Before switching refs, `git reset --hard HEAD` + `git clean -fd` drops
- *   tracked-file edits and untracked files left by a prior run. We skip the
- *   `-x` flag so `.gitignore`d content (node_modules, target, dist) survives
- *   between runs — matches the convention in pull-request/creator.ts and
- *   avoids an expensive reinstall every sync.
- * - For a tag, detached-HEAD checkout of that tag.
- * - For a branch, `checkout -B <branch> origin/<branch>` — force-updates
- *   the local branch to the remote tip in one step, which also works on
- *   the first sync when the local branch doesn't exist yet.
- *
- * This workspace is edsger-managed; callers should not put local work here.
- */
-export declare function syncRepoToRef(repoPath: string, ref: {
-    tag?: string;
-    branch?: string;
-}, token: string): void;
-/**
- * Set up an issue's repo for work (install deps, etc.)
- * This is called after cloning or reusing a repo
- */
-export declare function setupIssueRepo(repoPath: string): void;
-/**
- * Remove a cloned repo workspace after a successful task. Matches the
- * pr-resolve cleanup convention: best-effort, never throws — a missing dir
- * or locked file shouldn't fail an otherwise-successful run. Callers are
- * expected to skip cleanup on failure so the user can inspect partial state.
- *
- * No-ops when `repoPath` is undefined so callers can pass an optional path
- * without an extra guard at every call site.
- */
-export declare function cleanupIssueRepo(repoPath: string | undefined): void;
-/**
- * Update the remote token for an issue repo
- * Used when the installation token has been refreshed
- */
-export declare function updateRepoToken(repoPath: string, owner: string, repo: string, _token: string): void;

package/dist/workspace/workspace-manager.js

@@ -1,280 +0,0 @@
-/**
- * Workspace Manager - Manages the edsger working directory and issue repos
- *
- * Handles:
- * - Detecting or creating the 'edsger' working directory
- * - Cloning repos using GitHub App installation tokens
- * - Using issue ID as directory name for cloned repos
- * - Reusing existing cloned repos for the same issue
- */
-import { execFileSync, execSync } from 'child_process';
-import { existsSync, mkdirSync, rmSync } from 'fs';
-import { basename, join } from 'path';
-import { buildCredentialArgs } from '../utils/git-push.js';
-import { logError, logInfo, logSuccess, logWarning } from '../utils/logger.js';
-const WORKSPACE_DIR_NAME = 'edsger';
-/**
- * Determine the workspace root directory.
- *
- * Rules:
- * - If current directory basename is 'edsger', use it as workspace root
- * - Otherwise, create an 'edsger' subdirectory in the current directory
- */
-export function getWorkspaceRoot() {
-    const cwd = process.cwd();
-    const currentDirName = basename(cwd);
-    if (currentDirName === WORKSPACE_DIR_NAME) {
-        return cwd;
-    }
-    const workspaceDir = join(cwd, WORKSPACE_DIR_NAME);
-    return workspaceDir;
-}
-/**
- * Ensure the workspace directory exists
- */
-export function ensureWorkspaceDir() {
-    const workspaceRoot = getWorkspaceRoot();
-    if (!existsSync(workspaceRoot)) {
-        mkdirSync(workspaceRoot, { recursive: true });
-        logInfo(`Created workspace directory: ${workspaceRoot}`);
-    }
-    return workspaceRoot;
-}
-/**
- * Get the directory path for an issue's repo clone
- * Uses the issue ID as the directory name
- */
-export function getIssueRepoPath(workspaceRoot, issueId) {
-    return join(workspaceRoot, issueId);
-}
-/**
- * Check if an issue's repo already exists locally
- */
-export function issueRepoExists(workspaceRoot, issueId) {
-    const repoPath = getIssueRepoPath(workspaceRoot, issueId);
-    return existsSync(join(repoPath, '.git'));
-}
-/**
- * Clone a repository for an issue using GitHub App installation token
- *
- * Uses `git -c credential.helper` to pass the token securely
- * instead of embedding it in the clone URL (which would be visible via `ps`).
- *
- * @param workspaceRoot - The workspace root directory
- * @param issueId - The issue ID (used as directory name)
- * @param owner - GitHub repo owner
- * @param repo - GitHub repo name
- * @param token - GitHub installation token
- * @returns IssueRepo with the path and clone status
- */
-export function cloneIssueRepo(workspaceRoot, issueId, owner, repo, token) {
-    const repoPath = getIssueRepoPath(workspaceRoot, issueId);
-    const repoUrl = `https://github.com/${owner}/${repo}.git`;
-    // Use the shared credential helper builder. Passes the installation
-    // token via `git -c credential.helper=...` so it stays out of the
-    // remote URL and the process list.
-    const gitCredentialArgs = buildCredentialArgs(token);
-    // Check if already cloned
-    if (existsSync(join(repoPath, '.git'))) {
-        logInfo(`Reusing existing repo for issue ${issueId}`);
-        // Update the remote URL (without token) and fetch using credential helper
-        try {
-            execSync(`git remote set-url origin "${repoUrl}"`, {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-        }
-        catch {
-            logWarning('Could not update remote URL');
-        }
-        // Fetch latest changes using credential helper
-        // Use execFileSync to avoid shell interpretation of credential helper metacharacters
-        try {
-            execFileSync('git', [...gitCredentialArgs, 'fetch', 'origin'], {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-            logInfo('Fetched latest changes from remote');
-        }
-        catch {
-            logWarning('Could not fetch latest changes');
-        }
-        return { repoPath, freshClone: false };
-    }
-    // Clone fresh using credential helper
-    logInfo(`Cloning ${owner}/${repo} for issue ${issueId}...`);
-    // Use execFileSync to avoid shell interpretation of credential helper metacharacters
-    try {
-        execFileSync('git', [...gitCredentialArgs, 'clone', repoUrl, repoPath], {
-            stdio: 'pipe',
-        });
-        logSuccess(`Cloned ${owner}/${repo} to ${repoPath}`);
-        return { repoPath, freshClone: true };
-    }
-    catch (error) {
-        logError(`Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`);
-        throw error;
-    }
-}
-/**
- * Loose validator for a git ref name (tag or branch) coming from callers
- * that pass data originating from external sources (GitHub API, AI output).
- *
- * Rules match `git check-ref-format` plus a length cap. Rejecting bad
- * input early keeps it out of execFileSync argv.
- */
-export function isSafeGitRef(ref) {
-    if (typeof ref !== 'string') {
-        return false;
-    }
-    if (ref.length === 0 || ref.length > 100) {
-        return false;
-    }
-    if (/\s/.test(ref)) {
-        return false;
-    }
-    if (/^[-.]/.test(ref)) {
-        return false;
-    }
-    if (ref.includes('..') || ref.includes('@{')) {
-        return false;
-    }
-    return /^[A-Za-z0-9._\-+/@]+$/.test(ref);
-}
-/**
- * Sync a cloned issue repo to a specific git ref — a tag or a branch.
- *
- * Behaviour:
- * - `git fetch origin --tags --prune` brings in new tags (release tags!) and
- *   drops deleted remote branches, using the installation-token credential
- *   helper so private repos keep working.
- * - Before switching refs, `git reset --hard HEAD` + `git clean -fd` drops
- *   tracked-file edits and untracked files left by a prior run. We skip the
- *   `-x` flag so `.gitignore`d content (node_modules, target, dist) survives
- *   between runs — matches the convention in pull-request/creator.ts and
- *   avoids an expensive reinstall every sync.
- * - For a tag, detached-HEAD checkout of that tag.
- * - For a branch, `checkout -B <branch> origin/<branch>` — force-updates
- *   the local branch to the remote tip in one step, which also works on
- *   the first sync when the local branch doesn't exist yet.
- *
- * This workspace is edsger-managed; callers should not put local work here.
- */
-export function syncRepoToRef(repoPath, ref, token) {
-    if (!existsSync(join(repoPath, '.git'))) {
-        throw new Error(`Not a git repo: ${repoPath}`);
-    }
-    if (!ref.tag && !ref.branch) {
-        throw new Error('syncRepoToRef requires either tag or branch');
-    }
-    if (ref.tag && !isSafeGitRef(ref.tag)) {
-        throw new Error(`Unsafe tag ref: ${JSON.stringify(ref.tag)}`);
-    }
-    if (ref.branch && !isSafeGitRef(ref.branch)) {
-        throw new Error(`Unsafe branch ref: ${JSON.stringify(ref.branch)}`);
-    }
-    const creds = buildCredentialArgs(token);
-    // Timeouts so a hung proxy / credential prompt can't wedge the CLI
-    // forever. Network op gets more headroom than local ones.
-    const NET_TIMEOUT_MS = 120_000;
-    const LOCAL_TIMEOUT_MS = 30_000;
-    try {
-        execFileSync('git', [...creds, 'fetch', 'origin', '--tags', '--prune'], {
-            cwd: repoPath,
-            stdio: 'pipe',
-            timeout: NET_TIMEOUT_MS,
-        });
-    }
-    catch {
-        logWarning('git fetch failed during sync; working tree may be stale');
-    }
-    // Discard any residual state from a previous run before switching refs.
-    // Use `-fd` (not `-fdx`) to preserve .gitignore'd build output / deps.
-    try {
-        execFileSync('git', ['reset', '--hard', 'HEAD'], {
-            cwd: repoPath,
-            stdio: 'pipe',
-            timeout: LOCAL_TIMEOUT_MS,
-        });
-        execFileSync('git', ['clean', '-fd'], {
-            cwd: repoPath,
-            stdio: 'pipe',
-            timeout: LOCAL_TIMEOUT_MS,
-        });
-    }
-    catch {
-        // Non-fatal; subsequent checkout will surface any real issue.
-    }
-    try {
-        if (ref.tag) {
-            execFileSync('git', ['-c', 'advice.detachedHead=false', 'checkout', `refs/tags/${ref.tag}`], { cwd: repoPath, stdio: 'pipe', timeout: LOCAL_TIMEOUT_MS });
-            logInfo(`Checked out tag ${ref.tag}`);
-        }
-        else if (ref.branch) {
-            // Create-or-reset local branch to origin tip.
-            execFileSync('git', ['checkout', '-B', ref.branch, `origin/${ref.branch}`], { cwd: repoPath, stdio: 'pipe', timeout: LOCAL_TIMEOUT_MS });
-            logInfo(`Checked out branch ${ref.branch} at origin/${ref.branch}`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to checkout ${ref.tag ?? ref.branch}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Set up an issue's repo for work (install deps, etc.)
- * This is called after cloning or reusing a repo
- */
-export function setupIssueRepo(repoPath) {
-    // Check for package.json and install deps if needed
-    if (existsSync(join(repoPath, 'package.json'))) {
-        try {
-            logInfo('Installing dependencies...');
-            execSync('npm install', {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-            logSuccess('Dependencies installed');
-        }
-        catch {
-            logWarning('Could not install dependencies automatically');
-        }
-    }
-}
-/**
- * Remove a cloned repo workspace after a successful task. Matches the
- * pr-resolve cleanup convention: best-effort, never throws — a missing dir
- * or locked file shouldn't fail an otherwise-successful run. Callers are
- * expected to skip cleanup on failure so the user can inspect partial state.
- *
- * No-ops when `repoPath` is undefined so callers can pass an optional path
- * without an extra guard at every call site.
- */
-export function cleanupIssueRepo(repoPath) {
-    if (!repoPath) {
-        return;
-    }
-    try {
-        rmSync(repoPath, { recursive: true, force: true });
-        logInfo(`Cleaned up workspace: ${repoPath}`);
-    }
-    catch {
-        // Best-effort.
-    }
-}
-/**
- * Update the remote token for an issue repo
- * Used when the installation token has been refreshed
- */
-export function updateRepoToken(repoPath, owner, repo, _token) {
-    // Set remote URL without token (credentials are provided per-operation via credential helper)
-    try {
-        const repoUrl = `https://github.com/${owner}/${repo}.git`;
-        execSync(`git remote set-url origin "${repoUrl}"`, {
-            cwd: repoPath,
-            stdio: 'pipe',
-        });
-    }
-    catch {
-        logWarning('Could not update remote URL');
-    }
-}