codehere 0.6.1 → 0.7.0

package/dist/infrastructure/context/adapters/figma-source.js

@@ -0,0 +1,163 @@
+/**
+ * Figma context-source adapter (v0.8 S1 · second reference adapter).
+ *
+ * URL shapes:
+ *   figma://file/<file-key>                  · whole-file metadata + top-level frames
+ *   figma://file/<file-key>/node/<node-id>   · one node + its children, flattened
+ *
+ * Returns the design tree as indented plain text: frame names, types,
+ * dimensions, text content of TEXT nodes, fill colors when they're solid.
+ * Generated previews + raster bytes are skipped · agents read text, not
+ * pixels (overlay-renderer in v0.9 will surface raw frames separately).
+ *
+ * Auth: ctx.config['figma'] = { token: '<personal-access-token>' }
+ * Token comes from figma.com/developers/api · personal access token.
+ */
+import { ContextSourceError, estimateTokens, } from '../context-source.js';
+const FIGMA_API = 'https://api.figma.com/v1';
+const MAX_TREE_NODES = 200;
+const MAX_TEXT_PER_NODE = 240;
+function parsePath(url) {
+    // figma://file/<key> · hostname = 'file', pathname = '/<key>'
+    // figma://file/<key>/node/<id>
+    const host = url.host || url.hostname; // 'file'
+    if (host !== 'file') {
+        throw new ContextSourceError('figma', 'invalid_url', `URL must start with figma://file/<key>; got host='${host}'`);
+    }
+    const parts = url.pathname.split('/').filter(Boolean);
+    if (!parts.length) {
+        throw new ContextSourceError('figma', 'invalid_url', 'missing file key in figma:// URL');
+    }
+    const fileKey = parts[0];
+    let nodeId = null;
+    if (parts.length >= 3 && parts[1] === 'node') {
+        nodeId = decodeURIComponent(parts.slice(2).join('/'));
+    }
+    return { fileKey, nodeId };
+}
+export const figmaSource = {
+    id: 'figma',
+    label: 'Figma',
+    scheme: 'figma',
+    description: 'Fetch a Figma file or single node (tree, dimensions, text content)',
+    isConfigured(ctx) {
+        const cfg = ctx.config['figma'];
+        if (!cfg)
+            return false;
+        if (cfg.oauth?.accessToken)
+            return true;
+        return typeof cfg.token === 'string' && cfg.token.length > 8;
+    },
+    async fetch(url, ctx) {
+        const cfg = ctx.config['figma'] ?? {};
+        // Figma supports BOTH a personal-access token (X-Figma-Token header) AND
+        // an OAuth bearer (Authorization: Bearer ...) · pick whichever is set.
+        let headers;
+        if (cfg.oauth?.accessToken) {
+            headers = { Authorization: `Bearer ${cfg.oauth.accessToken}` };
+        }
+        else if (cfg.token) {
+            headers = { 'X-Figma-Token': cfg.token };
+        }
+        else {
+            throw new ContextSourceError('figma', 'auth', 'no token or OAuth in ctx.config["figma"]');
+        }
+        const { fileKey, nodeId } = parsePath(url);
+        const endpoint = cfg.endpoint ?? FIGMA_API;
+        let res;
+        if (nodeId) {
+            const target = `${endpoint}/files/${encodeURIComponent(fileKey)}/nodes?ids=${encodeURIComponent(nodeId)}`;
+            res = await ctx.httpGet(target, headers);
+        }
+        else {
+            const target = `${endpoint}/files/${encodeURIComponent(fileKey)}?depth=2`;
+            res = await ctx.httpGet(target, headers);
+        }
+        if (res.status === 401 || res.status === 403) {
+            throw new ContextSourceError('figma', 'auth', `Figma returned ${res.status}`);
+        }
+        if (res.status === 404) {
+            throw new ContextSourceError('figma', 'not_found', `file ${fileKey} not found`);
+        }
+        if (res.status === 429) {
+            throw new ContextSourceError('figma', 'rate_limit', 'Figma rate limit hit');
+        }
+        if (res.status !== 200) {
+            throw new ContextSourceError('figma', 'network', `Figma returned ${res.status}: ${res.body.slice(0, 200)}`);
+        }
+        let text;
+        let metadata;
+        if (nodeId) {
+            const parsed = JSON.parse(res.body);
+            if (parsed.err)
+                throw new ContextSourceError('figma', 'parse', `Figma error: ${parsed.err}`);
+            const node = parsed.nodes?.[nodeId]?.document;
+            if (!node)
+                throw new ContextSourceError('figma', 'not_found', `node ${nodeId} not in response`);
+            text = renderNodeAsTree(node, fileKey, nodeId);
+            metadata = { fileKey, nodeId, type: node.type, name: node.name };
+        }
+        else {
+            const parsed = JSON.parse(res.body);
+            if (parsed.err)
+                throw new ContextSourceError('figma', 'parse', `Figma error: ${parsed.err}`);
+            if (!parsed.document)
+                throw new ContextSourceError('figma', 'parse', 'Figma response missing document');
+            text = renderFile(parsed, fileKey);
+            metadata = { fileKey, name: parsed.name ?? null, lastModified: parsed.lastModified ?? null };
+        }
+        return {
+            url: url.toString(),
+            source: 'figma',
+            fetchedAt: new Date(ctx.now ? ctx.now() : Date.now()).toISOString(),
+            text,
+            estimatedTokens: estimateTokens(text),
+            metadata,
+        };
+    },
+};
+function renderFile(file, fileKey) {
+    const lines = [];
+    lines.push(`Figma file · ${file.name ?? '(unnamed)'}`);
+    lines.push(`https://www.figma.com/file/${fileKey}`);
+    if (file.lastModified)
+        lines.push(`updated: ${file.lastModified}`);
+    lines.push('');
+    if (file.document) {
+        lines.push('--- top-level tree (depth 2) ---');
+        renderInto(lines, file.document, 0, { remaining: MAX_TREE_NODES });
+    }
+    return lines.join('\n');
+}
+function renderNodeAsTree(node, fileKey, nodeId) {
+    const lines = [];
+    lines.push(`Figma node · ${node.name} (${node.type})`);
+    lines.push(`https://www.figma.com/file/${fileKey}?node-id=${encodeURIComponent(nodeId)}`);
+    lines.push('');
+    renderInto(lines, node, 0, { remaining: MAX_TREE_NODES });
+    return lines.join('\n');
+}
+function renderInto(out, node, depth, budget) {
+    if (budget.remaining <= 0) {
+        if (budget.remaining === 0) {
+            out.push('...[tree truncated · node budget reached]');
+            budget.remaining = -1;
+        }
+        return;
+    }
+    budget.remaining -= 1;
+    const indent = '  '.repeat(depth);
+    const bb = node.absoluteBoundingBox;
+    const dim = bb ? ` ${Math.round(bb.width)}×${Math.round(bb.height)}` : '';
+    const visible = node.visible === false ? ' [hidden]' : '';
+    let line = `${indent}${node.type} · ${node.name}${dim}${visible}`;
+    if (node.characters) {
+        const t = node.characters.replace(/\s+/g, ' ').slice(0, MAX_TEXT_PER_NODE);
+        line += ` · "${t}${node.characters.length > MAX_TEXT_PER_NODE ? '…' : ''}"`;
+    }
+    out.push(line);
+    for (const child of node.children ?? []) {
+        renderInto(out, child, depth + 1, budget);
+    }
+}
+//# sourceMappingURL=figma-source.js.map

package/dist/infrastructure/context/adapters/github-issue-source.js

@@ -0,0 +1,159 @@
+/**
+ * GitHub Issues context-source adapter (v0.8 S5 · community-shaped reference).
+ *
+ * Demonstrates that the context-source primitive isn't Linear/Figma-shaped
+ * by accident · the same contract serves a no-auth REST API. Any community
+ * contributor should be able to ship an adapter by copying THIS file, not
+ * the OAuth-heavy linear-source.ts.
+ *
+ * URL shape: `github://<owner>/<repo>/issues/<number>` (or `/pull/<number>`,
+ * which GitHub treats as an issue under the hood).
+ *
+ * Public-issues-only by default · no auth needed. If ctx.config['github']
+ * provides a `token`, we send it as a Bearer header to raise the rate
+ * limit + read private repos the token has scopes for.
+ *
+ * Returns: title, state, author, body, last N comments. Same shape as
+ * linear-source so prompts feel uniform across providers.
+ */
+import { ContextSourceError, estimateTokens, } from '../context-source.js';
+const GH_API = 'https://api.github.com';
+const MAX_BODY_CHARS = 4000;
+const MAX_COMMENT_CHARS = 600;
+const MAX_COMMENTS = 10;
+function parseRef(url) {
+    // URL: `github://<owner>/<repo>/issues/<number>` or `.../pull/<number>`
+    const host = url.host || url.hostname;
+    const path = url.pathname || '';
+    // Path begins with '/' · split
+    const parts = [host, ...path.split('/').filter(Boolean)];
+    if (parts.length < 4) {
+        throw new ContextSourceError('github', 'invalid_url', 'use github://<owner>/<repo>/issues/<number> or github://<owner>/<repo>/pull/<number>');
+    }
+    const [owner, repo, kind, numStr] = parts;
+    if (!/^[A-Za-z0-9._-]+$/.test(owner) || !/^[A-Za-z0-9._-]+$/.test(repo)) {
+        throw new ContextSourceError('github', 'invalid_url', 'owner/repo must be alphanumeric');
+    }
+    if (kind !== 'issues' && kind !== 'pull') {
+        throw new ContextSourceError('github', 'invalid_url', `expected /issues/ or /pull/ · got /${kind}/`);
+    }
+    const number = Number.parseInt(numStr, 10);
+    if (!Number.isInteger(number) || number <= 0) {
+        throw new ContextSourceError('github', 'invalid_url', `not an issue number: '${numStr}'`);
+    }
+    return { owner, repo, number };
+}
+export const githubIssueSource = {
+    id: 'github',
+    label: 'GitHub Issues',
+    scheme: 'github',
+    description: 'Fetch a public GitHub issue or PR (title, body, recent comments) · no auth needed',
+    isConfigured() {
+        // Always available · public issues need no auth.
+        return true;
+    },
+    async fetch(url, ctx) {
+        const ref = parseRef(url);
+        const cfg = ctx.config['github'] ?? {};
+        const endpoint = cfg.endpoint ?? GH_API;
+        const headers = {
+            Accept: 'application/vnd.github+json',
+            'X-GitHub-Api-Version': '2022-11-28',
+            'User-Agent': 'codehere/0.8',
+        };
+        if (cfg.token)
+            headers['Authorization'] = `Bearer ${cfg.token}`;
+        const issueRes = await ctx.httpGet(`${endpoint}/repos/${ref.owner}/${ref.repo}/issues/${ref.number}`, headers);
+        if (issueRes.status === 404) {
+            throw new ContextSourceError('github', 'not_found', `${ref.owner}/${ref.repo}#${ref.number} not found`);
+        }
+        // GitHub returns 403 for BOTH rate-limit and auth · disambiguate by body
+        // sniff first (rate-limit responses say "API rate limit exceeded").
+        if (issueRes.status === 429 || (issueRes.status === 403 && /rate limit/i.test(issueRes.body))) {
+            throw new ContextSourceError('github', 'rate_limit', 'GitHub API rate limit hit');
+        }
+        if (issueRes.status === 401 || issueRes.status === 403) {
+            throw new ContextSourceError('github', 'auth', `GitHub returned ${issueRes.status} · public issues should work without a token; private ones need ctx.config["github"].token`);
+        }
+        if (issueRes.status !== 200) {
+            throw new ContextSourceError('github', 'network', `GitHub returned ${issueRes.status}: ${issueRes.body.slice(0, 200)}`);
+        }
+        let issue;
+        try {
+            issue = JSON.parse(issueRes.body);
+        }
+        catch (err) {
+            throw new ContextSourceError('github', 'parse', `GitHub issue response not JSON: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // Comments are paginated · fetch the most recent page (sort=created direction=desc)
+        let comments = [];
+        if ((issue.comments ?? 0) > 0) {
+            const cRes = await ctx.httpGet(`${endpoint}/repos/${ref.owner}/${ref.repo}/issues/${ref.number}/comments?per_page=${MAX_COMMENTS}&sort=created&direction=desc`, headers);
+            if (cRes.status === 200) {
+                try {
+                    comments = JSON.parse(cRes.body).reverse(); // chronological for display
+                }
+                catch {
+                    // Non-fatal · we still have the issue body.
+                    comments = [];
+                }
+            }
+        }
+        const text = renderIssueAsPlainText(ref, issue, comments);
+        return {
+            url: url.toString(),
+            source: 'github',
+            fetchedAt: new Date(ctx.now ? ctx.now() : Date.now()).toISOString(),
+            text,
+            estimatedTokens: estimateTokens(text),
+            metadata: {
+                owner: ref.owner,
+                repo: ref.repo,
+                number: ref.number,
+                title: issue.title,
+                state: issue.state,
+                author: issue.user?.login ?? null,
+                html_url: issue.html_url,
+                commentCount: comments.length,
+            },
+        };
+    },
+};
+function renderIssueAsPlainText(ref, issue, comments) {
+    const lines = [];
+    lines.push(`GitHub ${ref.owner}/${ref.repo}#${issue.number} · ${issue.title}`);
+    lines.push(issue.html_url);
+    lines.push('');
+    lines.push(`state: ${issue.state}`);
+    if (issue.user?.login)
+        lines.push(`author: ${issue.user.login}`);
+    if (issue.assignee?.login)
+        lines.push(`assignee: ${issue.assignee.login}`);
+    if (issue.labels?.length) {
+        const names = issue.labels
+            .map((l) => l.name)
+            .filter(Boolean)
+            .join(', ');
+        if (names)
+            lines.push(`labels: ${names}`);
+    }
+    lines.push(`updated: ${issue.updated_at}`);
+    lines.push('');
+    lines.push('--- body ---');
+    const body = (issue.body ?? '').slice(0, MAX_BODY_CHARS);
+    lines.push(body || '(no body)');
+    if ((issue.body ?? '').length > MAX_BODY_CHARS) {
+        lines.push(`...[truncated · body is ${issue.body.length} chars]`);
+    }
+    if (comments.length) {
+        lines.push('');
+        lines.push(`--- last ${comments.length} comment${comments.length === 1 ? '' : 's'} ---`);
+        for (const c of comments) {
+            const who = c.user?.login ?? 'unknown';
+            const body = (c.body ?? '').slice(0, MAX_COMMENT_CHARS).replace(/\s+\n/g, '\n');
+            lines.push(`[${c.created_at}] ${who}: ${body}${(c.body ?? '').length > MAX_COMMENT_CHARS ? '...' : ''}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=github-issue-source.js.map

package/dist/infrastructure/context/adapters/linear-source.js

@@ -0,0 +1,190 @@
+/**
+ * Linear context-source adapter (v0.8 S1 · first reference adapter).
+ *
+ * URL shape: `linear://<TEAM-KEY>-<NUMBER>` · e.g. `linear://INFRA-247`.
+ *
+ * Returns the issue's title, status, assignee, description, and the last N
+ * comments as plain text. Token usage is bounded · a 5K-char issue with
+ * a 200-comment thread doesn't get spammed in full · we keep the top of the
+ * description + the last 10 comments by default.
+ *
+ * Auth: ctx.config['linear'] = { apiKey: '<personal-api-key>' }
+ * Get a key from linear.app/settings/api · personal key OR OAuth-issued token.
+ *
+ * Local-first: codehere never stores the issue payload on disk · the agent
+ * reads it once into prompt context, the audit chain records WHEN we fetched
+ * and BYTES we got but never the content. If the user wants persistence,
+ * that's their git tree.
+ */
+import { ContextSourceError, estimateTokens, } from '../context-source.js';
+const LINEAR_API = 'https://api.linear.app/graphql';
+const MAX_DESCRIPTION_CHARS = 4000;
+const MAX_COMMENT_CHARS = 600;
+const MAX_COMMENTS = 10;
+/** Resolve the auth header value from either OAuth or manual key. */
+function authToken(cfg) {
+    if (cfg.oauth?.accessToken)
+        return `Bearer ${cfg.oauth.accessToken}`;
+    if (cfg.apiKey)
+        return cfg.apiKey;
+    return null;
+}
+function parseIdentifier(parsed) {
+    // URL parses `linear://INFRA-247` with host = 'infra-247' (lowercased).
+    // The pathname is empty. Reassemble + uppercase the team key.
+    const host = parsed.host || parsed.hostname;
+    if (!host)
+        throw new ContextSourceError('linear', 'invalid_url', 'no issue identifier in URL');
+    // Linear identifiers are <TEAM>-<NUMBER> · normalize case so callers can
+    // write `linear://infra-247` and we still hit `INFRA-247`.
+    const upper = host.toUpperCase();
+    if (!/^[A-Z][A-Z0-9_]*-\d+$/.test(upper)) {
+        throw new ContextSourceError('linear', 'invalid_url', `not a Linear identifier: '${host}'`);
+    }
+    return upper;
+}
+const ISSUE_QUERY = `query($id: String!) {
+  issue(id: $id) {
+    id identifier title description url priority priorityLabel createdAt updatedAt
+    state { name type }
+    assignee { name }
+    team { key name }
+    comments(last: ${MAX_COMMENTS}) {
+      nodes { id body createdAt user { name } }
+    }
+  }
+}`;
+export const linearSource = {
+    id: 'linear',
+    label: 'Linear',
+    scheme: 'linear',
+    description: 'Fetch a Linear issue (title, status, description, recent comments)',
+    isConfigured(ctx) {
+        const cfg = ctx.config['linear'];
+        if (!cfg)
+            return false;
+        if (cfg.oauth?.accessToken)
+            return true;
+        return typeof cfg.apiKey === 'string' && cfg.apiKey.length > 8;
+    },
+    async fetch(url, ctx) {
+        const cfg = ctx.config['linear'] ?? {};
+        const auth = authToken(cfg);
+        if (!auth) {
+            throw new ContextSourceError('linear', 'auth', 'no apiKey or OAuth token in ctx.config["linear"]');
+        }
+        const identifier = parseIdentifier(url);
+        const endpoint = cfg.endpoint ?? LINEAR_API;
+        const headers = {
+            Authorization: auth,
+            'Content-Type': 'application/json',
+        };
+        const body = JSON.stringify({ query: ISSUE_QUERY, variables: { id: identifier } });
+        // ContextSourceFetchContext gives us httpGet; we POST GraphQL via a
+        // small helper since httpGet is GET-only in the canonical signature.
+        // For now we go through the same path but with a `body` smuggled in
+        // via headers · NOT pretty. Future: add httpPost to the context. The
+        // shape is identical (status, body, headers) so adapters port cleanly.
+        const httpPost = ctx.httpPost;
+        let res;
+        if (httpPost) {
+            res = await httpPost(endpoint, body, headers);
+        }
+        else {
+            // Production fallback · use fetch directly. Tests inject httpPost so
+            // they never reach this branch.
+            const fr = await fetch(endpoint, { method: 'POST', headers, body });
+            res = {
+                status: fr.status,
+                body: await fr.text(),
+                headers: Object.fromEntries(fr.headers),
+            };
+        }
+        if (res.status === 401 || res.status === 403) {
+            throw new ContextSourceError('linear', 'auth', `Linear returned ${res.status}`);
+        }
+        if (res.status === 404) {
+            throw new ContextSourceError('linear', 'not_found', `issue ${identifier} not found`);
+        }
+        if (res.status === 429) {
+            throw new ContextSourceError('linear', 'rate_limit', 'Linear rate limit hit');
+        }
+        if (res.status !== 200) {
+            throw new ContextSourceError('linear', 'network', `Linear returned ${res.status}: ${res.body.slice(0, 200)}`);
+        }
+        let payload;
+        try {
+            payload = JSON.parse(res.body);
+        }
+        catch (err) {
+            throw new ContextSourceError('linear', 'parse', `Linear response not JSON: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (payload.errors?.length) {
+            throw new ContextSourceError('linear', 'parse', `Linear GraphQL errors: ${payload.errors.map((e) => e.message).join('; ')}`);
+        }
+        const issue = payload.data?.issue;
+        if (!issue) {
+            throw new ContextSourceError('linear', 'not_found', `issue ${identifier} returned null`);
+        }
+        const text = renderIssueAsPlainText(issue);
+        return {
+            url: url.toString(),
+            source: 'linear',
+            fetchedAt: new Date(ctx.now ? ctx.now() : Date.now()).toISOString(),
+            text,
+            estimatedTokens: estimateTokens(text),
+            metadata: {
+                identifier: issue.identifier,
+                title: issue.title,
+                url: issue.url,
+                state: issue.state?.name,
+                stateType: issue.state?.type,
+                assignee: issue.assignee?.name ?? null,
+                priorityLabel: issue.priorityLabel ?? null,
+                priority: issue.priority,
+                description: issue.description ?? null,
+                commentCount: issue.comments?.nodes.length ?? 0,
+                // Structured comments for the overlay-renderer's Linear inline view.
+                comments: (issue.comments?.nodes ?? []).map((c) => ({
+                    author: c.user?.name ?? 'unknown',
+                    body: c.body,
+                    createdAt: c.createdAt,
+                })),
+            },
+        };
+    },
+};
+function renderIssueAsPlainText(issue) {
+    const lines = [];
+    lines.push(`Linear issue ${issue.identifier} · ${issue.title}`);
+    lines.push(issue.url);
+    lines.push('');
+    if (issue.state)
+        lines.push(`status: ${issue.state.name} (${issue.state.type})`);
+    if (issue.assignee)
+        lines.push(`assignee: ${issue.assignee.name}`);
+    if (issue.priorityLabel)
+        lines.push(`priority: ${issue.priorityLabel}`);
+    if (issue.team)
+        lines.push(`team: ${issue.team.name} (${issue.team.key})`);
+    lines.push(`updated: ${issue.updatedAt}`);
+    lines.push('');
+    lines.push('--- description ---');
+    const desc = (issue.description ?? '').slice(0, MAX_DESCRIPTION_CHARS);
+    lines.push(desc || '(no description)');
+    if ((issue.description ?? '').length > MAX_DESCRIPTION_CHARS) {
+        lines.push(`...[truncated · description is ${issue.description.length} chars]`);
+    }
+    const comments = issue.comments?.nodes ?? [];
+    if (comments.length) {
+        lines.push('');
+        lines.push(`--- last ${comments.length} comment${comments.length === 1 ? '' : 's'} ---`);
+        for (const c of comments) {
+            const who = c.user?.name ?? 'unknown';
+            const body = c.body.slice(0, MAX_COMMENT_CHARS).replace(/\s+\n/g, '\n');
+            lines.push(`[${c.createdAt}] ${who}: ${body}${c.body.length > MAX_COMMENT_CHARS ? '...' : ''}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=linear-source.js.map

package/dist/infrastructure/context/context-resolver.js

@@ -0,0 +1,144 @@
+/**
+ * Context resolver · v0.8 S2 · integrates context-sources into the spawn path.
+ *
+ * What it does: scans the user's prompt for any context-source URL
+ * (linear://..., figma://..., draw.io://..., etc.), resolves each one via
+ * the registry, and returns an enriched prompt with the resolved content
+ * appended as a structured preamble. Audit lines emit on every resolve.
+ *
+ * Why a separate module: the registry is pure data and the adapters are
+ * pure async functions, but spawn() is synchronous-feeling code. This module
+ * is the seam where we wait on async fetches before the agent starts.
+ *
+ * Two principles:
+ *   1. Best-effort by default. If one URL fails (auth, network, 404), we log
+ *      the error inline in the preamble and CONTINUE with the others rather
+ *      than failing the whole spawn. The agent still gets the user's prompt
+ *      + whatever resolved; the audit chain still gets every error.
+ *   2. The resolved content goes into the prompt as a `[context-source ...]`
+ *      block, NOT as a tool-call result. Tool-call wiring belongs in the
+ *      adapters themselves; this layer is a pre-prompt enrichment.
+ */
+import { fetchViaRegistry, } from './context-source.js';
+/* ──────────────────────────────────────────────────────────────────────── */
+/* URL extraction                                                            */
+/* ──────────────────────────────────────────────────────────────────────── */
+/**
+ * Extract every URL whose scheme is registered in the given registry. We do
+ * NOT extract `http(s)` URLs · those are usually documentation links, not
+ * something to inline.
+ *
+ * Scheme matching: case-insensitive; URLs can appear inline mid-sentence
+ * surrounded by punctuation. We tokenize loosely (whitespace + a few
+ * trailing punctuation chars) so `(linear://INFRA-247).` doesn't include
+ * the period or paren.
+ */
+export function extractContextSourceUrls(prompt, reg) {
+    if (!prompt)
+        return [];
+    const schemes = Array.from(reg.bySchemeOnly.keys());
+    if (!schemes.length)
+        return [];
+    // Build a regex that anchors on any registered scheme.
+    const schemePart = schemes.map(escapeRe).join('|');
+    // Tokens: <scheme>://<chars-until-trailing-punct-or-whitespace>
+    const re = new RegExp(`\\b(${schemePart})://[^\\s<>"\`]+`, 'gi');
+    const seen = new Set();
+    const out = [];
+    for (const match of prompt.matchAll(re)) {
+        // Strip trailing punctuation a user is likely to include accidentally.
+        const cleaned = match[0].replace(/[.,;:!?)\]}]+$/, '');
+        if (!seen.has(cleaned)) {
+            seen.add(cleaned);
+            out.push(cleaned);
+        }
+    }
+    return out;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Walk the prompt, resolve every registered URL in parallel, append the
+ * payloads as a preamble. Best-effort: any single failure is logged in the
+ * preamble and in the audit chain; the spawn proceeds.
+ */
+export async function resolveContextSourceUrls(prompt, reg, ctx) {
+    const urls = extractContextSourceUrls(prompt, reg);
+    if (urls.length === 0) {
+        return { enrichedPrompt: prompt, outcomes: [], totalEstimatedTokens: 0 };
+    }
+    // Resolve in parallel · network-bound, no shared state, safe to fanout.
+    // Cap fanout to a small number to avoid hammering one provider when a
+    // user pastes 50 Linear URLs at once.
+    const MAX_PARALLEL = 4;
+    const outcomes = [];
+    const payloads = [];
+    for (let i = 0; i < urls.length; i += MAX_PARALLEL) {
+        const batch = urls.slice(i, i + MAX_PARALLEL);
+        const settled = await Promise.allSettled(batch.map((u) => fetchViaRegistry(reg, u, ctx).then((p) => ({ url: u, payload: p }))));
+        for (let j = 0; j < settled.length; j++) {
+            const r = settled[j];
+            const url = batch[j];
+            if (r.status === 'fulfilled') {
+                const { payload } = r.value;
+                if (payload === null) {
+                    outcomes.push({ url, status: 'unknown_scheme' });
+                }
+                else {
+                    outcomes.push({
+                        url,
+                        status: 'ok',
+                        source: payload.source,
+                        bytes: payload.text.length,
+                        estimatedTokens: payload.estimatedTokens,
+                    });
+                    payloads.push({ url, payload });
+                }
+            }
+            else {
+                const err = r.reason;
+                const isUnconfigured = /not configured/i.test(err.message);
+                outcomes.push({
+                    url,
+                    status: isUnconfigured ? 'unconfigured' : 'error',
+                    detail: err.message,
+                });
+            }
+        }
+    }
+    const totalEstimatedTokens = payloads.reduce((sum, p) => sum + p.payload.estimatedTokens, 0);
+    const enrichedPrompt = buildEnrichedPrompt(prompt, payloads, outcomes);
+    return { enrichedPrompt, outcomes, totalEstimatedTokens };
+}
+function buildEnrichedPrompt(prompt, payloads, outcomes) {
+    if (payloads.length === 0 && outcomes.every((o) => o.status === 'ok' || o.status === 'unknown_scheme')) {
+        // Nothing resolved AND no errors worth reporting · skip the preamble entirely.
+        return prompt;
+    }
+    const lines = [];
+    lines.push('--- context resolved by codehere ---');
+    lines.push('The user referenced these external resources. Their content is included below for your reference.');
+    lines.push('');
+    for (const { url, payload } of payloads) {
+        lines.push(`[context-source ${payload.source} · ${url}]`);
+        lines.push(payload.text);
+        lines.push('');
+    }
+    // Report errors inline so the agent knows what it's missing rather than
+    // silently working without it.
+    const errors = outcomes.filter((o) => o.status === 'error' || o.status === 'unconfigured');
+    if (errors.length) {
+        lines.push('--- context-source errors ---');
+        for (const e of errors) {
+            lines.push(`[${e.status}] ${e.url} · ${e.detail ?? '(no detail)'}`);
+        }
+        lines.push('');
+    }
+    lines.push('--- end of context-source preamble ---');
+    lines.push('');
+    lines.push('User prompt below this line:');
+    lines.push(prompt);
+    return lines.join('\n');
+}
+//# sourceMappingURL=context-resolver.js.map