@delfini/action-core 0.1.0

package/dist/analysis-input.js

@@ -0,0 +1,60 @@
+import * as core from '@actions/core';
+import * as github from '@actions/github';
+import { buildUnifiedDiff } from './diff-builder.js';
+import { filterDiff } from '@delfini/drift-engine';
+// Story P2.2 (AC6) — extracted verbatim from pipeline.ts. The Lite pipeline
+// reuses this without importing pipeline.ts as a value, which would pull the
+// FR88g/FR88d module graph (config-client / stream-routing / intake-client)
+// into lite-pipeline.ts's runtime graph and break the epic's "Lite never calls
+// FR88g/FR88d" invariant. `buildUnifiedDiff` + the `@actions/github` context
+// carry no FR88d coupling, so this is a clean shared module.
+export function buildAnalysisInput(ctx, changedFiles, docs, options = {}) {
+    let diff = buildUnifiedDiff(changedFiles);
+    if (options.enableDiffPreFilter === true) {
+        const result = filterDiff(diff);
+        diff = result.keptDiff;
+        // One info line; no per-path logs to keep a large lockfile churn from
+        // flooding the Action log. Counts only — sufficient to diagnose under-
+        // or over-aggressive filtering without leaking diff content.
+        //
+        // Count BOTH droppedPaths and droppedHunks per reason: a file whose every
+        // hunk is whitespace-only / import-only is promoted to a path-level drop
+        // with that reason, so a path-bucket-only summary would render whole-file
+        // whitespace/import drops invisible (AC3 — drops must never be silently
+        // discarded).
+        const counts = countByReason([
+            ...result.droppedPaths.map((p) => p.reason),
+            ...result.droppedHunks.map((h) => h.reason),
+        ]);
+        core.info(`Delfini diff pre-filter dropped: lockfiles=${counts.lockfile} ` +
+            `generated=${counts.generated} vendored=${counts.vendored} ` +
+            `fixtures=${counts.fixture} whitespace=${counts['whitespace-only']} ` +
+            `import=${counts['import-only']}`);
+    }
+    const prTitle = github.context.payload.pull_request?.title ?? '';
+    return {
+        diff,
+        docs,
+        prMetadata: {
+            owner: ctx.owner,
+            repo: ctx.repo,
+            prNumber: ctx.pullNumber,
+            headSha: ctx.headSha,
+            baseSha: ctx.baseSha,
+            title: prTitle,
+        },
+    };
+}
+function countByReason(reasons) {
+    const out = {
+        lockfile: 0,
+        generated: 0,
+        vendored: 0,
+        fixture: 0,
+        'whitespace-only': 0,
+        'import-only': 0,
+    };
+    for (const r of reasons)
+        out[r]++;
+    return out;
+}

package/dist/diff-builder.d.ts

@@ -0,0 +1,16 @@
+import type { ChangedFile } from './github-client-shared.js';
+/**
+ * Builds a unified-diff string from the GitHub API's per-file patch entries.
+ *
+ * GitHub's `pulls.listFiles` returns each file's hunks (the `@@ ... @@` content)
+ * but omits the `diff --git` / `--- a/… +++ b/…` preamble. We synthesise that
+ * preamble so the resulting string is a valid multi-file unified diff and so
+ * the single-call prompt-builder's `diff --git` counter (for `changedFileCount`)
+ * sees the right file count.
+ *
+ * Files without a `patch` (binary, renamed-only, or >GitHub's per-file size cap)
+ * are skipped entirely per the Story 3.2 design decision: we never lie to the
+ * LLM about what changed when we can't actually show it.
+ */
+export declare function buildUnifiedDiff(files: ChangedFile[]): string;
+//# sourceMappingURL=diff-builder.d.ts.map

package/dist/diff-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-builder.d.ts","sourceRoot":"","sources":["../src/diff-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,CAuB7D"}

package/dist/diff-builder.js

@@ -0,0 +1,35 @@
+/**
+ * Builds a unified-diff string from the GitHub API's per-file patch entries.
+ *
+ * GitHub's `pulls.listFiles` returns each file's hunks (the `@@ ... @@` content)
+ * but omits the `diff --git` / `--- a/… +++ b/…` preamble. We synthesise that
+ * preamble so the resulting string is a valid multi-file unified diff and so
+ * the single-call prompt-builder's `diff --git` counter (for `changedFileCount`)
+ * sees the right file count.
+ *
+ * Files without a `patch` (binary, renamed-only, or >GitHub's per-file size cap)
+ * are skipped entirely per the Story 3.2 design decision: we never lie to the
+ * LLM about what changed when we can't actually show it.
+ */
+export function buildUnifiedDiff(files) {
+    const parts = [];
+    for (const file of files) {
+        if (!file.patch)
+            continue;
+        parts.push(`diff --git a/${file.filename} b/${file.filename}`);
+        if (file.status === 'added') {
+            parts.push(`--- /dev/null`);
+            parts.push(`+++ b/${file.filename}`);
+        }
+        else if (file.status === 'removed') {
+            parts.push(`--- a/${file.filename}`);
+            parts.push(`+++ /dev/null`);
+        }
+        else {
+            parts.push(`--- a/${file.filename}`);
+            parts.push(`+++ b/${file.filename}`);
+        }
+        parts.push(file.patch);
+    }
+    return parts.join('\n');
+}

package/dist/doc-exclusion.d.ts

@@ -0,0 +1,17 @@
+export type ExclusionReason = 'front-matter';
+export interface ExcludedDoc {
+    path: string;
+    reason: ExclusionReason;
+    detail?: string;
+}
+export interface FrontMatterResult {
+    ignore: boolean;
+    reason?: string;
+    body: string;
+    frontMatterLineCount: number;
+}
+type WarnFn = (message: string) => void;
+export declare function parseFrontMatter(markdown: string, onWarn?: WarnFn): FrontMatterResult;
+export declare function stripFrontMatter(markdown: string): string;
+export {};
+//# sourceMappingURL=doc-exclusion.d.ts.map

package/dist/doc-exclusion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-exclusion.d.ts","sourceRoot":"","sources":["../src/doc-exclusion.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,eAAe,GAAG,cAAc,CAAA;AAE5C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IAOZ,oBAAoB,EAAE,MAAM,CAAA;CAC7B;AAuBD,KAAK,MAAM,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;AAEvC,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,MAAiB,GACxB,iBAAiB,CAuEnB;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMzD"}

package/dist/doc-exclusion.js

@@ -0,0 +1,85 @@
+import matter from 'gray-matter';
+// Counts the number of lines occupied by the YAML front-matter block in `markdown`.
+// Returns 0 when no front-matter is present. Robust to CRLF / LF; the closing
+// `---` may sit on its own line or be followed by trailing whitespace — both
+// shapes are matched. If a leading `---` is present but no closing `---` is
+// found within a reasonable bound, returns 0 (defensive — prevents counting
+// the entire file as front-matter on a malformed doc).
+const FRONT_MATTER_OPEN_RE = /^---\r?\n/;
+function countFrontMatterLines(markdown) {
+    if (!FRONT_MATTER_OPEN_RE.test(markdown))
+        return 0;
+    const lines = markdown.split(/\r?\n/);
+    // First line is the opening `---`. Search for the closing `---` from line 2.
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i] === '---') {
+            // i is 0-indexed; the closing `---` is on line `i + 1` (1-indexed),
+            // and the block occupies that many lines.
+            return i + 1;
+        }
+    }
+    return 0;
+}
+export function parseFrontMatter(markdown, onWarn = () => { }) {
+    // Compute the line count from the original markdown — independent of
+    // gray-matter's parse outcome — so a malformed YAML fallback still produces
+    // a useful `frontMatterLineCount` rather than `0`. (Counter-argument: a
+    // malformed YAML block is also a sign the structure is suspect; defaulting
+    // the count to 0 in the catch path matches the body fallback to original
+    // markdown — both say "treat the whole file as body".)
+    let parsed;
+    try {
+        parsed = matter(markdown);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        onWarn(`Failed to parse front-matter: ${reason}`);
+        return { ignore: false, body: markdown, frontMatterLineCount: 0 };
+    }
+    const data = parsed.data;
+    const body = parsed.content;
+    const frontMatterLineCount = countFrontMatterLines(markdown);
+    if (!('delfini' in data)) {
+        return { ignore: false, body, frontMatterLineCount };
+    }
+    const value = data.delfini;
+    // Shorthand: delfini: ignore | skip  (or delfini: true)
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'ignore' || normalized === 'skip') {
+            return { ignore: true, body, frontMatterLineCount };
+        }
+        onWarn(`Unrecognised front-matter value for 'delfini': "${value}" — expected "ignore" or "skip". Treating as not-ignored.`);
+        return { ignore: false, body, frontMatterLineCount };
+    }
+    if (typeof value === 'boolean') {
+        return { ignore: value, body, frontMatterLineCount };
+    }
+    if (value !== null && typeof value === 'object') {
+        const obj = value;
+        const ignoreFlag = obj.ignore;
+        const skipFlag = obj.skip;
+        const rawReason = obj.reason;
+        const reason = typeof rawReason === 'string' && rawReason.trim().length > 0
+            ? rawReason.trim()
+            : undefined;
+        if (ignoreFlag === true || skipFlag === true) {
+            return { ignore: true, reason, body, frontMatterLineCount };
+        }
+        if (ignoreFlag === false || skipFlag === false) {
+            return { ignore: false, body, frontMatterLineCount };
+        }
+        onWarn(`Front-matter 'delfini' object did not contain a boolean 'ignore' or 'skip' flag. Treating as not-ignored.`);
+        return { ignore: false, body, frontMatterLineCount };
+    }
+    onWarn(`Front-matter 'delfini' value has unsupported type (${typeof value}). Treating as not-ignored.`);
+    return { ignore: false, body, frontMatterLineCount };
+}
+export function stripFrontMatter(markdown) {
+    try {
+        return matter(markdown).content;
+    }
+    catch {
+        return markdown;
+    }
+}

package/dist/doc-reader.d.ts

@@ -0,0 +1,34 @@
+import type { GitHub } from '@actions/github/lib/utils';
+import { type ExcludedDoc } from './doc-exclusion.js';
+export interface DocFile {
+    path: string;
+    content: string;
+    frontMatterLineCount: number;
+}
+export interface DocsReadResult {
+    included: DocFile[];
+    excluded: ExcludedDoc[];
+    scope: ScopeSource;
+}
+export type ScopeSource = {
+    kind: 'docs_path';
+    docScope: string;
+};
+type Octokit = InstanceType<typeof GitHub>;
+export type ReadDocsOptions = Record<string, never>;
+export declare function readDocsViaGitTrees(octokit: Octokit, owner: string, repo: string, docScope: string[], ref: string, _options?: ReadDocsOptions): Promise<DocsReadResult>;
+/**
+ * Lite-mode reader wrapper. Always reads at the PR head SHA (`ctx.headSha`),
+ * matching `github-client.ts:readDocs`'s rationale: walking at base would
+ * re-detect the same drift forever once Approve-and-Commit splices doc
+ * updates onto the PR branch (Story P2.6 carries the rationale forward;
+ * Lite mode has no Approve-and-Commit but the head-vs-base distinction is
+ * still the correct one for analysing "what the PR's current docs look like").
+ *
+ * Lives here rather than in `github-client.ts` to keep the new reader and its
+ * wrapper colocated. Story 3.12 retired `readDocsFromPath`; BOTH modes read
+ * via this git-trees path now (Full through `github-client.ts:readDocs`).
+ */
+export declare function readDocsAtHeadViaGitTrees(octokit: Octokit, owner: string, repo: string, docScope: string[], headSha: string, options?: ReadDocsOptions): Promise<DocsReadResult>;
+export {};
+//# sourceMappingURL=doc-reader.d.ts.map

package/dist/doc-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-reader.d.ts","sourceRoot":"","sources":["../src/doc-reader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAEvD,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,oBAAoB,CAAA;AAE3B,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IAIf,oBAAoB,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,QAAQ,EAAE,WAAW,EAAE,CAAA;IACvB,KAAK,EAAE,WAAW,CAAA;CACnB;AAQD,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAEjE,KAAK,OAAO,GAAG,YAAY,CAAC,OAAO,MAAM,CAAC,CAAA;AAE1C,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AAmHnD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,eAAoB,GAC7B,OAAO,CAAC,cAAc,CAAC,CA6EzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC,CAEzB"}

package/dist/doc-reader.js

@@ -0,0 +1,172 @@
+import * as core from '@actions/core';
+import { isFileInDocScope } from '@delfini/drift-engine';
+import { parseFrontMatter, } from './doc-exclusion.js';
+// Story 3.12 (ADR-2026-06-01) — the per-directory `getContent` walk
+// (`readDocsFromPath` + `collectDocs`) is retired. BOTH modes now read docs
+// via `readDocsViaGitTrees` (ONE recursive git-trees call + the shared
+// `isFileInDocScope` matcher). Full mode reaches it through
+// `readDocsAtHeadViaGitTrees` (github-client.ts:readDocs); Lite mode reaches
+// it directly (lite-pipeline.ts).
+async function processFile(octokit, owner, repo, filePath, ref, out) {
+    const content = await fetchFileContent(octokit, owner, repo, filePath, ref);
+    if (content === null) {
+        return;
+    }
+    const frontMatter = parseFrontMatter(content, (message) => {
+        core.warning(`${filePath}: ${message}`);
+    });
+    if (frontMatter.ignore) {
+        out.excluded.push({
+            path: filePath,
+            reason: 'front-matter',
+            detail: frontMatter.reason,
+        });
+        return;
+    }
+    out.included.push({
+        path: filePath,
+        content: frontMatter.body,
+        frontMatterLineCount: frontMatter.frontMatterLineCount,
+    });
+}
+async function fetchFileContent(octokit, owner, repo, path, ref) {
+    try {
+        const { data } = await octokit.rest.repos.getContent({
+            owner,
+            repo,
+            path,
+            ref,
+        });
+        if (Array.isArray(data) || data.type !== 'file' || !data.content) {
+            return null;
+        }
+        return Buffer.from(data.content, 'base64').toString('utf-8');
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+function isNotFoundError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'status' in error &&
+        error.status === 404);
+}
+// ----------------------------------------------------------------------------
+// Story P2.6 / ADR-2026-06-01 — multi-path / glob doc-scope reader
+// ----------------------------------------------------------------------------
+//
+// `readDocsViaGitTrees` is the new Lite-mode reader. It replaces the Lite
+// pipeline's per-directory `getContent` walk (`readDocsFromPath`) with ONE
+// recursive git-trees call, filters every blob path through the shared
+// `isFileInDocScope` predicate from `@delfini/drift-engine` (picomatch@4
+// dialect), then fetches only the matched `.md` blobs.
+//
+// Why git-trees: the Contents API has no glob support; the trees API is the
+// only tractable way to glob a remote tree and is usually FEWER round-trips
+// than the directory walk. Dialect parity with smart-skip is enforced by
+// construction — the SAME `isFileInDocScope` runs against the SAME `string[]`
+// scope on both sides (the 23-row dialect-parity fixture in
+// `packages/drift-engine/__tests__/fixtures/doc-scope-dialect.json` gates it).
+//
+// Story 3.12 retired `readDocsFromPath` — Full mode now reaches this reader
+// via `readDocsAtHeadViaGitTrees` (github-client.ts:readDocs), at full
+// multi-path/glob parity with Lite mode.
+const MAX_CONCURRENT_BLOB_FETCHES = 8;
+const MARKDOWN_EXTENSIONS = ['.md', '.markdown'];
+function isMarkdownPath(path) {
+    const lower = path.toLowerCase();
+    return MARKDOWN_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+export async function readDocsViaGitTrees(octokit, owner, repo, docScope, ref, _options = {}) {
+    // Joined string for the internal `ScopeSource.docScope` display field — keeps
+    // the existing `{kind: 'docs_path'; docScope: string}` shape byte-identical
+    // for downstream log/display consumers (Story P2.6 AC4 default per the
+    // Questions for the User answer). `ScopeSource` is internal to apps/action;
+    // widening to `string | string[]` is a forward option for Story 3.12.
+    const scopeDisplay = docScope.join(', ');
+    const result = {
+        included: [],
+        excluded: [],
+        scope: { kind: 'docs_path', docScope: scopeDisplay },
+    };
+    // Empty scope -> empty result, never analyse. Matches FR57(b)'s "no
+    // doc-in-scope files" baseline; never fall through to a recursive call
+    // against an empty scope (would match every blob).
+    if (docScope.length === 0) {
+        return result;
+    }
+    let treeData;
+    try {
+        const response = await octokit.rest.git.getTree({
+            owner,
+            repo,
+            tree_sha: ref,
+            // The Octokit REST typing accepts the string '1' here (cast on the
+            // wire to a query param). Boolean `true` works at runtime but is not
+            // strictly typed.
+            recursive: '1',
+        });
+        treeData = response.data;
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            core.warning(`git tree for ref ${ref} not found — returning empty docs list`);
+            return result;
+        }
+        throw error;
+    }
+    // V1 truncated-tree contract: warn-and-proceed. A truncated tree means the
+    // user has a very large monorepo and the response hit GitHub's size cap;
+    // some docs may be missed. A correctness-first follow-up walks the tree
+    // subtree-by-subtree on truncation — backlogged.
+    if (treeData.truncated) {
+        core.warning(`git tree for ${ref} was truncated by GitHub; some docs may be missed. ` +
+            'Consider narrowing docs_path or splitting the repo.');
+    }
+    const tree = (treeData.tree ?? []);
+    const matchedPaths = [];
+    for (const entry of tree) {
+        if (entry.type !== 'blob')
+            continue;
+        const path = entry.path;
+        if (typeof path !== 'string' || path.length === 0)
+            continue;
+        if (!isFileInDocScope(path, docScope))
+            continue;
+        // The predicate is path-shape-only (P3.6.1 AC5). The `.md` / `.markdown`
+        // restriction is an expander concern — apply it AFTER the in-scope check.
+        if (!isMarkdownPath(path))
+            continue;
+        matchedPaths.push(path);
+    }
+    // Concurrency-capped blob fetch. A repo with thousands of matched .md files
+    // could otherwise trip GitHub's secondary rate limit. The cap is a safety
+    // floor, not a perf knob.
+    for (let i = 0; i < matchedPaths.length; i += MAX_CONCURRENT_BLOB_FETCHES) {
+        const batch = matchedPaths.slice(i, i + MAX_CONCURRENT_BLOB_FETCHES);
+        await Promise.all(batch.map((path) => processFile(octokit, owner, repo, path, ref, result)));
+    }
+    // Stable output order — git-trees response order can vary; tests depend on
+    // determinism for snapshot-style assertions.
+    result.included.sort((a, b) => a.path.localeCompare(b.path));
+    return result;
+}
+/**
+ * Lite-mode reader wrapper. Always reads at the PR head SHA (`ctx.headSha`),
+ * matching `github-client.ts:readDocs`'s rationale: walking at base would
+ * re-detect the same drift forever once Approve-and-Commit splices doc
+ * updates onto the PR branch (Story P2.6 carries the rationale forward;
+ * Lite mode has no Approve-and-Commit but the head-vs-base distinction is
+ * still the correct one for analysing "what the PR's current docs look like").
+ *
+ * Lives here rather than in `github-client.ts` to keep the new reader and its
+ * wrapper colocated. Story 3.12 retired `readDocsFromPath`; BOTH modes read
+ * via this git-trees path now (Full through `github-client.ts:readDocs`).
+ */
+export async function readDocsAtHeadViaGitTrees(octokit, owner, repo, docScope, headSha, options = {}) {
+    return readDocsViaGitTrees(octokit, owner, repo, docScope, headSha, options);
+}

package/dist/github-client-shared.d.ts

@@ -0,0 +1,27 @@
+import type { GitHub } from '@actions/github/lib/utils';
+import type { DocFile, DocsReadResult, ReadDocsOptions } from './doc-reader.js';
+export type { DocFile, DocsReadResult, ReadDocsOptions };
+export interface PrContext {
+    owner: string;
+    repo: string;
+    pullNumber: number;
+    headSha: string;
+    baseSha: string;
+}
+export interface ChangedFile {
+    filename: string;
+    status: string;
+    patch?: string;
+}
+type Octokit = InstanceType<typeof GitHub>;
+export declare function getPrContext(): PrContext;
+export declare function listChangedFiles(octokit: Octokit, ctx: PrContext): Promise<ChangedFile[]>;
+export declare function getFileContent(octokit: Octokit, ctx: PrContext, path: string, ref: string): Promise<string | null>;
+export declare function readDocs(octokit: Octokit, ctx: PrContext, docScope: string[], options?: ReadDocsOptions): Promise<DocsReadResult>;
+export declare const DELFINI_PR_COMMENT_MARKER = "<!-- delfini-pr-comment -->";
+export declare function postOrUpdatePrComment(octokit: Octokit, ctx: PrContext, body: string, options: {
+    marker: string;
+}): Promise<void>;
+export declare function isForbiddenError(error: unknown): boolean;
+export declare function createCheckStatus(octokit: Octokit, ctx: PrContext, conclusion: 'in_progress' | 'success' | 'failure' | 'neutral' | 'action_required', title: string, summary: string, detailsUrl?: string): Promise<void>;
+//# sourceMappingURL=github-client-shared.d.ts.map

package/dist/github-client-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-client-shared.d.ts","sourceRoot":"","sources":["../src/github-client-shared.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAEvD,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAO/E,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,CAAA;AAExD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,KAAK,OAAO,GAAG,YAAY,CAAC,OAAO,MAAM,CAAC,CAAA;AAE1C,wBAAgB,YAAY,IAAI,SAAS,CA4BxC;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,SAAS,GACb,OAAO,CAAC,WAAW,EAAE,CAAC,CAiCxB;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyBxB;AAED,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,SAAS,EACd,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC,CAezB;AAsBD,eAAO,MAAM,yBAAyB,gCAAgC,CAAA;AAEtE,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1B,OAAO,CAAC,IAAI,CAAC,CA8Ef;AAgBD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAExD;AAED,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,SAAS,EACd,UAAU,EAAE,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,iBAAiB,EACjF,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAqCf"}