@loicngr/kobo 1.7.16 → 1.7.17

package/dist/server/services/change-source-branch-service.js

@@ -0,0 +1,150 @@
+// src/server/services/change-source-branch-service.ts
+import { spawn } from 'node:child_process';
+import * as path from 'node:path';
+import * as gitOps from '../utils/git-ops.js';
+import { getAgentStatus } from './agent/orchestrator.js';
+import { getForgeProvider } from './forge/registry.js';
+import { resolveForge } from './forge/resolve.js';
+import { getEffectiveSettings } from './settings-service.js';
+import { getWorkspace, updateWorkspaceSourceBranch } from './workspace-service.js';
+/** Above this many proper commits, refuse and ask for a manual rebase. */
+export const MAX_PROPER_COMMITS = 50;
+/** Wall-clock limit on the custom change-source-branch script. */
+const SCRIPT_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * Re-target a workspace onto `newBase`: reconstruct its working branch via
+ * cherry-pick of its proper commits, update the `source_branch` metadata, and
+ * change the PR base if a PR exists. Throws on validation failures (agent
+ * running, unknown base). Returns a status discriminating the outcome.
+ */
+export async function changeSourceBranch(workspaceId, newBase) {
+    const workspace = getWorkspace(workspaceId);
+    if (!workspace)
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    if (getAgentStatus(workspaceId) !== null) {
+        throw new Error('Cannot change the source branch while the agent is running — stop it first');
+    }
+    const oldBase = workspace.sourceBranch;
+    const trimmedNew = newBase.trim();
+    if (!trimmedNew)
+        throw new Error('New source branch is required');
+    if (trimmedNew === oldBase)
+        throw new Error(`The source branch is already '${oldBase}'`);
+    const effective = getEffectiveSettings(workspace.projectPath);
+    if (effective.changeSourceBranchScript && effective.changeSourceBranchScript.trim().length > 0) {
+        return runCustomScript(workspace, oldBase, trimmedNew, effective.changeSourceBranchScript);
+    }
+    const worktreePath = workspace.worktreePath;
+    const workingBranch = workspace.workingBranch;
+    // Fetch every branch so all `origin/*` refs are current: the proper-commit
+    // computation and the `reset --hard` target both depend on fresh refs.
+    // Best-effort — offline still lets us proceed with whatever is local, and
+    // the branchExists check below is the authoritative gate for the new base
+    // (it throws a clean error, mapped to a 400, rather than a raw fetch error).
+    try {
+        gitOps.fetchAllBranches(worktreePath);
+    }
+    catch {
+        // offline / no remote — proceed with local refs
+    }
+    if (!gitOps.branchExists(worktreePath, trimmedNew, 'origin')) {
+        throw new Error(`Source branch 'origin/${trimmedNew}' does not exist`);
+    }
+    const commits = gitOps.listProperCommits(worktreePath, workingBranch, trimmedNew, oldBase);
+    const forcePushNeeded = gitOps.branchExists(worktreePath, workingBranch, 'origin');
+    if (commits.length > MAX_PROPER_COMMITS) {
+        return { status: 'too-many', forcePushNeeded, commitCount: commits.length };
+    }
+    const isAligned = commits.length === 0;
+    const dirty = gitOps.worktreeHasChanges(worktreePath);
+    if (!isAligned && dirty) {
+        return { status: 'dirty', forcePushNeeded, commitCount: commits.length };
+    }
+    const stashed = isAligned && dirty;
+    if (stashed)
+        gitOps.stashPush(worktreePath, 'kobo-change-source-branch');
+    try {
+        gitOps.reconstructBranchOnto(worktreePath, workingBranch, trimmedNew, commits);
+    }
+    catch (err) {
+        if (err instanceof gitOps.GitConflictError) {
+            // Record the new base even when conflicted: the cherry-pick is left in
+            // progress for the agent (or the cancel-source-change route) to resolve
+            // or abort. `stashed` is always false here — a conflict needs commits,
+            // the stash path is aligned-only — so no stash is stranded.
+            updateWorkspaceSourceBranch(workspaceId, trimmedNew);
+            return { status: 'conflict', forcePushNeeded, commitCount: commits.length };
+        }
+        throw err;
+    }
+    finally {
+        if (stashed)
+            gitOps.stashPop(worktreePath);
+    }
+    updateWorkspaceSourceBranch(workspaceId, trimmedNew);
+    try {
+        const provider = getForgeProvider(resolveForge(workspace.projectPath));
+        if (provider.capabilities.canChangePrBase) {
+            const pr = await provider.getPrStatus(worktreePath, workingBranch);
+            if (pr)
+                await provider.changePrBase(worktreePath, trimmedNew);
+        }
+    }
+    catch (err) {
+        console.error('[change-source-branch] PR base update failed (non-fatal):', err);
+    }
+    return { status: isAligned ? 'aligned' : 'done', forcePushNeeded, commitCount: commits.length };
+}
+/** Spawn the script with `bash -c`, return the standard result on exit 0, throw on non-zero. */
+async function runCustomScript(workspace, oldBase, newBase, script) {
+    const forgeId = resolveForge(workspace.projectPath);
+    const projectName = path.basename(workspace.projectPath);
+    // Best-effort PR/MR lookup — '' on no PR / missing CLI / forge='none'.
+    let prNumber = '';
+    try {
+        const provider = getForgeProvider(forgeId);
+        const snapshot = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
+        if (snapshot?.number)
+            prNumber = String(snapshot.number);
+    }
+    catch (err) {
+        console.warn('[change-source-branch] PR lookup failed, KOBO_PR_NUMBER will be empty:', err);
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn('bash', ['-c', script], {
+            cwd: workspace.worktreePath,
+            env: {
+                ...process.env,
+                KOBO_NEW_BASE: newBase,
+                KOBO_OLD_BASE: oldBase,
+                KOBO_WORKING_BRANCH: workspace.workingBranch,
+                KOBO_WORKTREE_PATH: workspace.worktreePath,
+                KOBO_PROJECT_PATH: workspace.projectPath,
+                KOBO_PROJECT_NAME: projectName,
+                KOBO_WORKSPACE_ID: workspace.id,
+                KOBO_WORKSPACE_NAME: workspace.name,
+                KOBO_FORGE: forgeId,
+                KOBO_PR_NUMBER: prNumber,
+            },
+            timeout: SCRIPT_TIMEOUT_MS,
+        });
+        let stderrBuf = '';
+        child.stderr?.on('data', (chunk) => {
+            stderrBuf += chunk.toString();
+            if (stderrBuf.length > 8 * 1024)
+                stderrBuf = stderrBuf.slice(-8 * 1024);
+        });
+        child.on('error', (err) => {
+            reject(new Error(`Custom change-source-branch script failed to spawn: ${err.message}`));
+        });
+        child.on('exit', (code, signal) => {
+            if (code === 0) {
+                updateWorkspaceSourceBranch(workspace.id, newBase);
+                resolve({ status: 'done', forcePushNeeded: false, commitCount: 0 });
+                return;
+            }
+            const detail = stderrBuf.trim().slice(-500) || `exit code ${code ?? signal ?? 'unknown'}`;
+            reject(new Error(`Custom change-source-branch script failed: ${detail}`));
+        });
+    });
+}

package/dist/server/services/chat-history-service.js

@@ -0,0 +1,41 @@
+import { getDb } from '../db/index.js';
+/** Hard cap on entries per workspace. The service trims after every insert. */
+const MAX_HISTORY_ENTRIES = 200;
+/** Returns up to MAX_HISTORY_ENTRIES messages for the workspace, most recent first. */
+export function listChatHistory(workspaceId) {
+    const db = getDb();
+    const rows = db
+        .prepare(`SELECT message FROM workspace_chat_history
+       WHERE workspace_id = ?
+       ORDER BY id DESC
+       LIMIT ${MAX_HISTORY_ENTRIES}`)
+        .all(workspaceId);
+    return rows.map((r) => r.message);
+}
+/**
+ * Insert a message into the workspace's history, dedup against the latest
+ * entry, and trim to MAX_HISTORY_ENTRIES. Whitespace-only messages are
+ * ignored. Atomic via a transaction so the insert + trim are observed
+ * together.
+ */
+export function pushChatHistory(workspaceId, message) {
+    if (!message?.trim())
+        return;
+    const db = getDb();
+    db.transaction(() => {
+        const latest = db
+            .prepare('SELECT message FROM workspace_chat_history WHERE workspace_id = ? ORDER BY id DESC LIMIT 1')
+            .get(workspaceId);
+        if (latest?.message === message)
+            return;
+        db.prepare('INSERT INTO workspace_chat_history (workspace_id, message) VALUES (?, ?)').run(workspaceId, message);
+        db.prepare(`DELETE FROM workspace_chat_history
+       WHERE workspace_id = ?
+         AND id NOT IN (
+           SELECT id FROM workspace_chat_history
+           WHERE workspace_id = ?
+           ORDER BY id DESC
+           LIMIT ${MAX_HISTORY_ENTRIES}
+         )`).run(workspaceId, workspaceId);
+    })();
+}

package/dist/server/services/file-editor-service.js

@@ -0,0 +1,59 @@
+import { createHash } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import * as path from 'node:path';
+import { getFileContent, writeFileInWorktree } from '../utils/git-ops.js';
+const MAX_FILE_BYTES = 1024 * 1024;
+export function shaOf(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+/**
+ * Persist `content` to `relativePath` inside `worktreePath`. Refuses when the
+ * current file's sha differs from `baseSha` (412 semantics), when the path
+ * escapes the worktree (including via symlinks), or when content exceeds 1 MB.
+ */
+export function saveWorkspaceFile(worktreePath, relativePath, content, baseSha) {
+    const absPath = resolveSafe(worktreePath, relativePath);
+    if (Buffer.byteLength(content, 'utf8') > MAX_FILE_BYTES) {
+        throw new Error(`File too large (max ${MAX_FILE_BYTES / 1024 / 1024} MB)`);
+    }
+    const current = getFileContent(worktreePath, relativePath) ?? '';
+    const currentSha = shaOf(current);
+    if (currentSha !== baseSha) {
+        return { status: 'conflict', currentSha };
+    }
+    writeFileInWorktree(absPath, content);
+    return { status: 'saved' };
+}
+function resolveSafe(worktreePath, relativePath) {
+    const abs = path.resolve(worktreePath, relativePath);
+    const root = realpathSync(path.resolve(worktreePath));
+    const rootWithSep = root + path.sep;
+    // Resolve the parent's realpath (parent must exist; if it doesn't, the path
+    // is invalid anyway and we surface that). Then join the lexical basename so
+    // a non-existent leaf doesn't trigger ENOENT.
+    let realParent;
+    try {
+        realParent = realpathSync(path.dirname(abs));
+    }
+    catch {
+        throw new Error(`Path '${relativePath}' is invalid (parent directory does not exist)`);
+    }
+    const realAbs = path.join(realParent, path.basename(abs));
+    if (realAbs !== root && !realAbs.startsWith(rootWithSep)) {
+        throw new Error(`Path '${relativePath}' escapes the worktree`);
+    }
+    // If the leaf exists and is itself a symlink, follow it and re-check
+    // containment so we never write through a symlink that escapes the worktree.
+    try {
+        const leafReal = realpathSync(realAbs);
+        if (leafReal !== root && !leafReal.startsWith(rootWithSep)) {
+            throw new Error(`Path '${relativePath}' escapes the worktree`);
+        }
+        return leafReal;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return realAbs;
+        throw err;
+    }
+}

package/dist/server/services/forge/github/provider.js

@@ -0,0 +1,121 @@
+// src/server/services/forge/github/provider.ts
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+// NOTE: `reviewThreads` is intentionally NOT in this list.
+// `gh pr view --json reviewThreads` is rejected with `Unknown JSON field`
+// — there is no stable `gh` version that exposes it. Until upstream adds it,
+// `unresolvedReviewThreadsCount` stays at 0. `reviewThreads` is kept in the
+// `RawGhPr` shape only so the mapper code stays forward-compatible.
+const GH_PR_FIELDS = [
+    'number',
+    'title',
+    'url',
+    'state',
+    'baseRefName',
+    'reviewDecision',
+    'author',
+    'assignees',
+    'labels',
+    'latestReviews',
+    'reviewRequests',
+    'statusCheckRollup',
+    'updatedAt',
+].join(',');
+function mapGhPrToSnapshot(raw) {
+    const reviewers = [];
+    const seen = new Set();
+    for (const r of raw.latestReviews ?? []) {
+        const login = r.author?.login;
+        if (!login || seen.has(login))
+            continue;
+        seen.add(login);
+        reviewers.push({ login, state: r.state ?? 'COMMENTED' });
+    }
+    for (const r of raw.reviewRequests ?? []) {
+        if (!r.login || seen.has(r.login))
+            continue;
+        seen.add(r.login);
+        reviewers.push({ login: r.login, state: 'PENDING' });
+    }
+    const checks = (raw.statusCheckRollup ?? []).map((c) => ({
+        name: c.name,
+        conclusion: c.conclusion ?? null,
+        status: c.status,
+        detailsUrl: c.detailsUrl ?? null,
+    }));
+    let rollup = null;
+    if (checks.length > 0) {
+        if (checks.some((c) => c.conclusion === 'FAILURE'))
+            rollup = 'FAILURE';
+        else if (checks.some((c) => c.status !== 'COMPLETED'))
+            rollup = 'PENDING';
+        else
+            rollup = 'SUCCESS';
+    }
+    const unresolvedReviewThreadsCount = (raw.reviewThreads ?? []).reduce((a, t) => a + (t.isResolved ? 0 : 1), 0);
+    return {
+        number: raw.number,
+        title: raw.title,
+        url: raw.url,
+        state: raw.state,
+        base: raw.baseRefName ?? '',
+        reviewDecision: raw.reviewDecision ?? null,
+        author: { login: raw.author?.login ?? '' },
+        assignees: (raw.assignees ?? []).map((a) => ({ login: a.login })),
+        reviewers,
+        labels: (raw.labels ?? []).map((l) => ({ name: l.name, color: l.color })),
+        ci: { rollup, checks },
+        updatedAt: raw.updatedAt ?? '',
+        unresolvedReviewThreadsCount,
+    };
+}
+/** Map an execFile rejection to a ForgeAvailability reason. */
+function availabilityFromError(err) {
+    const code = err.code;
+    if (code === 'ENOENT')
+        return { available: false, reason: 'cli_missing' };
+    const msg = err.message?.toLowerCase() ?? '';
+    if (msg.includes('not logged in') || msg.includes('gh auth login')) {
+        return { available: false, reason: 'not_authenticated' };
+    }
+    return { available: false };
+}
+export const githubProvider = {
+    id: 'github',
+    capabilities: { canCreatePr: true, canChangePrBase: true, requestTermShort: 'PR' },
+    async isAvailable(repoPath) {
+        try {
+            await execFileAsync('gh', ['auth', 'status'], { cwd: repoPath, encoding: 'utf-8' });
+            return { available: true };
+        }
+        catch (err) {
+            return availabilityFromError(err);
+        }
+    },
+    async getPrStatus(repoPath, branch) {
+        try {
+            const { stdout } = await execFileAsync('gh', ['pr', 'view', branch, '--json', GH_PR_FIELDS], {
+                cwd: repoPath,
+                encoding: 'utf-8',
+            });
+            const raw = stdout.trim();
+            if (!raw)
+                return null;
+            return mapGhPrToSnapshot(JSON.parse(raw));
+        }
+        catch {
+            return null;
+        }
+    },
+    async createPr(repoPath, opts) {
+        const { stdout } = await execFileAsync('gh', ['pr', 'create', '--base', opts.base, '--head', opts.head, '--title', opts.title, '--body', opts.body], { cwd: repoPath, encoding: 'utf-8' });
+        const match = stdout.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
+        if (!match)
+            throw new Error('Could not parse PR URL from gh output');
+        return { url: match[0], number: Number.parseInt(match[1], 10) };
+    },
+    async changePrBase(repoPath, base) {
+        await execFileAsync('gh', ['pr', 'edit', '--base', base], { cwd: repoPath, encoding: 'utf-8' });
+    },
+};

package/dist/server/services/forge/gitlab/provider.js

@@ -0,0 +1,178 @@
+// src/server/services/forge/gitlab/provider.ts
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/** Map GitLab MR state to the normalised PrSnapshot state. */
+function mapState(state) {
+    if (state === 'merged')
+        return 'MERGED';
+    if (state === 'closed')
+        return 'CLOSED';
+    return 'OPEN';
+}
+function mapGlabMrToSnapshot(raw) {
+    return {
+        number: raw.iid,
+        title: raw.title,
+        url: raw.web_url,
+        state: mapState(raw.state),
+        base: raw.target_branch ?? '',
+        // GitLab's approval model differs from GitHub review decisions; left null.
+        reviewDecision: null,
+        author: { login: raw.author?.username ?? '' },
+        assignees: (raw.assignees ?? []).map((a) => ({ login: a.username })),
+        reviewers: (raw.reviewers ?? []).map((r) => ({ login: r.username, state: 'PENDING' })),
+        // glab does not expose label colours in the MR view; default to ''.
+        labels: (raw.labels ?? []).map((name) => ({ name, color: '' })),
+        // ci is enriched by getPrStatus via fetchGlabCi (rollup + per-job checks);
+        // this default applies only if that enrichment call fails.
+        ci: { rollup: null, checks: [] },
+        updatedAt: raw.updated_at ?? '',
+        unresolvedReviewThreadsCount: 0,
+    };
+}
+/** Map a GitLab pipeline status string to the normalised CI rollup. */
+function mapPipelineRollup(status) {
+    switch (status) {
+        case 'failed':
+            return 'FAILURE';
+        case 'success':
+            return 'SUCCESS';
+        case 'canceled':
+            return 'CANCELLED';
+        case 'running':
+        case 'pending':
+        case 'created':
+        case 'preparing':
+        case 'scheduled':
+        case 'waiting_for_resource':
+            return 'PENDING';
+        default:
+            return null;
+    }
+}
+/**
+ * Map a GitLab pipeline job to a normalised PrCiCheck. The `status` /
+ * `conclusion` pair is chosen so `PrPanel.vue` groups the job correctly:
+ * non-`COMPLETED` → pending; `FAILURE`/`CANCELLED` → failed; `SUCCESS` →
+ * passed; `SKIPPED`/`NEUTRAL` → skipped.
+ */
+function mapGlabJobToCheck(job) {
+    let status = 'IN_PROGRESS';
+    let conclusion = null;
+    switch (job.status) {
+        case 'failed':
+            status = 'COMPLETED';
+            conclusion = 'FAILURE';
+            break;
+        case 'canceled':
+            status = 'COMPLETED';
+            conclusion = 'CANCELLED';
+            break;
+        case 'success':
+            status = 'COMPLETED';
+            conclusion = 'SUCCESS';
+            break;
+        case 'skipped':
+            status = 'COMPLETED';
+            conclusion = 'SKIPPED';
+            break;
+        case 'manual':
+            status = 'COMPLETED';
+            conclusion = 'NEUTRAL';
+            break;
+        default:
+            // created / pending / running / preparing / scheduled /
+            // waiting_for_resource / unknown — still in flight.
+            break;
+    }
+    return { name: job.name ?? '', conclusion, status, detailsUrl: job.web_url ?? null };
+}
+/**
+ * Best-effort latest-pipeline CI summary for a branch via `glab ci get`. The
+ * single JSON response carries both the pipeline `status` (the rollup) and a
+ * `jobs` array (the per-check detail). Never throws — a branch with no
+ * pipeline (or any glab error) yields `{ rollup: null, checks: [] }` so the
+ * caller can still return the MR snapshot.
+ */
+async function fetchGlabCi(repoPath, branch) {
+    try {
+        const { stdout } = await execFileAsync('glab', ['ci', 'get', '-b', branch, '-F', 'json'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+        const raw = stdout.trim();
+        if (!raw)
+            return { rollup: null, checks: [] };
+        const pipeline = JSON.parse(raw);
+        return {
+            rollup: mapPipelineRollup(pipeline.status),
+            checks: (pipeline.jobs ?? []).map(mapGlabJobToCheck),
+        };
+    }
+    catch {
+        return { rollup: null, checks: [] };
+    }
+}
+function availabilityFromError(err) {
+    const code = err.code;
+    if (code === 'ENOENT')
+        return { available: false, reason: 'cli_missing' };
+    const msg = err.message?.toLowerCase() ?? '';
+    if (msg.includes('not authenticated') || msg.includes('glab auth login')) {
+        return { available: false, reason: 'not_authenticated' };
+    }
+    return { available: false };
+}
+export const gitlabProvider = {
+    id: 'gitlab',
+    capabilities: { canCreatePr: true, canChangePrBase: true, requestTermShort: 'MR' },
+    async isAvailable(repoPath) {
+        try {
+            await execFileAsync('glab', ['auth', 'status'], { cwd: repoPath, encoding: 'utf-8' });
+            return { available: true };
+        }
+        catch (err) {
+            return availabilityFromError(err);
+        }
+    },
+    async getPrStatus(repoPath, branch) {
+        try {
+            const { stdout } = await execFileAsync('glab', ['mr', 'view', branch, '--output', 'json'], {
+                cwd: repoPath,
+                encoding: 'utf-8',
+            });
+            const raw = stdout.trim();
+            if (!raw)
+                return null;
+            const snapshot = mapGlabMrToSnapshot(JSON.parse(raw));
+            snapshot.ci = await fetchGlabCi(repoPath, branch);
+            return snapshot;
+        }
+        catch {
+            return null;
+        }
+    },
+    async createPr(repoPath, opts) {
+        const { stdout } = await execFileAsync('glab', [
+            'mr',
+            'create',
+            '--source-branch',
+            opts.head,
+            '--target-branch',
+            opts.base,
+            '--title',
+            opts.title,
+            '--description',
+            opts.body,
+            '--yes',
+        ], { cwd: repoPath, encoding: 'utf-8' });
+        const match = stdout.match(/https?:\/\/[^\s]+\/-\/merge_requests\/(\d+)/);
+        if (!match)
+            throw new Error('Could not parse MR URL from glab output');
+        return { url: match[0], number: Number.parseInt(match[1], 10) };
+    },
+    async changePrBase(repoPath, base) {
+        await execFileAsync('glab', ['mr', 'update', '--target-branch', base], { cwd: repoPath, encoding: 'utf-8' });
+    },
+};

package/dist/server/services/forge/none.js

@@ -0,0 +1,23 @@
+// src/server/services/forge/none.ts
+import { ForgeUnavailableError } from './types.js';
+/**
+ * Provider for projects with no supported forge. Read operations return
+ * `null` (no PR is a valid state); write operations throw so the route
+ * layer surfaces a clear message instead of attempting a CLI call.
+ */
+export const noneProvider = {
+    id: 'none',
+    capabilities: { canCreatePr: false, canChangePrBase: false, requestTermShort: 'PR' },
+    async isAvailable() {
+        return { available: false };
+    },
+    async getPrStatus() {
+        return null;
+    },
+    async createPr() {
+        throw new ForgeUnavailableError('This project has no supported forge configured');
+    },
+    async changePrBase() {
+        throw new ForgeUnavailableError('This project has no supported forge configured');
+    },
+};

package/dist/server/services/forge/registry.js

@@ -0,0 +1,17 @@
+// src/server/services/forge/registry.ts
+import { githubProvider } from './github/provider.js';
+import { gitlabProvider } from './gitlab/provider.js';
+import { noneProvider } from './none.js';
+const PROVIDERS = {
+    github: githubProvider,
+    gitlab: gitlabProvider,
+    none: noneProvider,
+};
+/** Resolve a provider by id. Unknown ids fall back to the none provider. */
+export function getForgeProvider(id) {
+    return PROVIDERS[id] ?? noneProvider;
+}
+/** The selectable forge ids, in display order. */
+export function listForges() {
+    return ['github', 'gitlab', 'none'];
+}

package/dist/server/services/forge/resolve.js

@@ -0,0 +1,34 @@
+// src/server/services/forge/resolve.ts
+import { execFileSync } from 'node:child_process';
+import { getProjectSettings } from '../settings-service.js';
+/** Classify a git remote URL into a forge id. Exported for testing. */
+export function forgeFromRemoteUrl(url) {
+    const lower = url.toLowerCase();
+    if (lower.includes('github.com'))
+        return 'github';
+    if (lower.includes('gitlab'))
+        return 'gitlab';
+    return 'none';
+}
+/** Read the `origin` remote URL, or '' when there is no remote. */
+function readRemoteUrl(projectPath) {
+    try {
+        return execFileSync('git', ['remote', 'get-url', 'origin'], {
+            cwd: projectPath,
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Resolve the forge for a project: the explicit per-project setting wins;
+ * `auto` (the default) classifies the origin remote URL.
+ */
+export function resolveForge(projectPath) {
+    const setting = getProjectSettings(projectPath)?.forge ?? 'auto';
+    if (setting === 'github' || setting === 'gitlab' || setting === 'none')
+        return setting;
+    return forgeFromRemoteUrl(readRemoteUrl(projectPath));
+}

package/dist/server/services/forge/types.js

@@ -0,0 +1,9 @@
+// src/server/services/forge/types.ts
+/** Thrown by write operations when the forge cannot service them. */
+export class ForgeUnavailableError extends Error {
+    code = 'forge_unavailable';
+    constructor(message) {
+        super(message);
+        this.name = 'ForgeUnavailableError';
+    }
+}

package/dist/server/services/git-stats-service.js

@@ -0,0 +1,32 @@
+// src/server/services/git-stats-service.ts
+import * as gitOps from '../utils/git-ops.js';
+import { getForgeProvider } from './forge/registry.js';
+import { resolveForge } from './forge/resolve.js';
+/**
+ * Compute the git + forge stats for a workspace branch. Pure read — does NOT
+ * run `fetchSourceBranchAsync`; the caller decides whether to refresh the
+ * local source ref first. `prUrl`/`prState` come from the supplied PR snapshot
+ * so this never issues its own `getPrStatus` call.
+ */
+export async function computeGitStats(workspace, prSnapshot) {
+    const { worktreePath, sourceBranch, workingBranch, projectPath } = workspace;
+    const commitCount = gitOps.getCommitCount(worktreePath, sourceBranch, workingBranch);
+    const behindCount = gitOps.getCommitsBehind(worktreePath, sourceBranch, workingBranch);
+    const diffStats = gitOps.getStructuredDiffStatsBetween(worktreePath, sourceBranch, workingBranch);
+    const unpushedCount = await gitOps.getUnpushedCountAsync(worktreePath, workingBranch);
+    const workingTree = gitOps.getWorkingTreeStatus(worktreePath);
+    const forgeProvider = getForgeProvider(resolveForge(projectPath));
+    const availability = await forgeProvider.isAvailable(worktreePath);
+    return {
+        commitCount,
+        behindCount,
+        filesChanged: diffStats.filesChanged,
+        insertions: diffStats.insertions,
+        deletions: diffStats.deletions,
+        prUrl: prSnapshot?.url ?? null,
+        prState: prSnapshot?.state ?? null,
+        unpushedCount,
+        workingTree,
+        forge: { id: forgeProvider.id, capabilities: forgeProvider.capabilities, availability },
+    };
+}