@cruxy/cli 1.0.3 → 1.0.5

package/dist/usage/types.d.ts

@@ -1,283 +0,0 @@
-import { z } from "zod";
-import { MODEL_TIERS } from "../brand/voice.js";
-/**
- * Usage telemetry + cost tracking (C.22): types for LOCAL, honest usage
- * accounting. Every number here is a real figure the provider reported — a token
- * count is present only when the provider returned usage for that request, and
- * `undefined` (never `0`) when it did not. Nothing in this module is ever
- * transmitted anywhere (see the module barrel's no-phone-home note).
- */
-/** Bump when the on-disk usage file shape changes (enables future migration). */
-export declare const USAGE_FILE_VERSION: 1;
-/**
- * One model request's usage. A request that reported no usage keeps
- * `inputTokens`/`outputTokens` as `undefined` — the honest "unknown", never
- * zero-filled or re-tokenized. A provider-reported `0` is stored as `0` (a real
- * count), so the two cases stay distinguishable downstream.
- */
-export declare const UsageEntrySchema: z.ZodObject<{
-    /** The routing tier (C.30) this request ran on; absent when routing is inert. */
-    tier: z.ZodOptional<z.ZodString>;
-    /** Provider-reported prompt tokens; `undefined` ⇔ no usage was reported. */
-    inputTokens: z.ZodOptional<z.ZodNumber>;
-    /** Provider-reported completion tokens; `undefined` ⇔ no usage was reported. */
-    outputTokens: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Prompt-cache tokens READ from a warm cache (phase-A caching, Anthropic dev
-     * path). `undefined` ⇔ the provider doesn't cache / reported nothing (the
-     * cruxy gateway today) — never zero-filled. Optional, so older on-disk
-     * entries without the field still parse.
-     */
-    cacheReadTokens: z.ZodOptional<z.ZodNumber>;
-    /** Prompt-cache tokens WRITTEN this request (the ~1.25× write premium); same `undefined`-≠-0 rule. */
-    cacheCreationTokens: z.ZodOptional<z.ZodNumber>;
-    /** ISO-8601 timestamp the request completed. */
-    at: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    at: string;
-    tier?: string | undefined;
-    inputTokens?: number | undefined;
-    outputTokens?: number | undefined;
-    cacheReadTokens?: number | undefined;
-    cacheCreationTokens?: number | undefined;
-}, {
-    at: string;
-    tier?: string | undefined;
-    inputTokens?: number | undefined;
-    outputTokens?: number | undefined;
-    cacheReadTokens?: number | undefined;
-    cacheCreationTokens?: number | undefined;
-}>;
-export type UsageEntry = z.infer<typeof UsageEntrySchema>;
-/** One run's usage: an ordered list of per-request entries. */
-export declare const UsageRecordSchema: z.ZodObject<{
-    /** Unique id for this run (one `session.send`). */
-    runId: z.ZodString;
-    /** Groups runs of one interactive session, so `--session` aggregates them. */
-    sessionId: z.ZodOptional<z.ZodString>;
-    /** ISO-8601 timestamp the run started. */
-    startedAt: z.ZodString;
-    entries: z.ZodArray<z.ZodObject<{
-        /** The routing tier (C.30) this request ran on; absent when routing is inert. */
-        tier: z.ZodOptional<z.ZodString>;
-        /** Provider-reported prompt tokens; `undefined` ⇔ no usage was reported. */
-        inputTokens: z.ZodOptional<z.ZodNumber>;
-        /** Provider-reported completion tokens; `undefined` ⇔ no usage was reported. */
-        outputTokens: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Prompt-cache tokens READ from a warm cache (phase-A caching, Anthropic dev
-         * path). `undefined` ⇔ the provider doesn't cache / reported nothing (the
-         * cruxy gateway today) — never zero-filled. Optional, so older on-disk
-         * entries without the field still parse.
-         */
-        cacheReadTokens: z.ZodOptional<z.ZodNumber>;
-        /** Prompt-cache tokens WRITTEN this request (the ~1.25× write premium); same `undefined`-≠-0 rule. */
-        cacheCreationTokens: z.ZodOptional<z.ZodNumber>;
-        /** ISO-8601 timestamp the request completed. */
-        at: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        at: string;
-        tier?: string | undefined;
-        inputTokens?: number | undefined;
-        outputTokens?: number | undefined;
-        cacheReadTokens?: number | undefined;
-        cacheCreationTokens?: number | undefined;
-    }, {
-        at: string;
-        tier?: string | undefined;
-        inputTokens?: number | undefined;
-        outputTokens?: number | undefined;
-        cacheReadTokens?: number | undefined;
-        cacheCreationTokens?: number | undefined;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    entries: {
-        at: string;
-        tier?: string | undefined;
-        inputTokens?: number | undefined;
-        outputTokens?: number | undefined;
-        cacheReadTokens?: number | undefined;
-        cacheCreationTokens?: number | undefined;
-    }[];
-    runId: string;
-    startedAt: string;
-    sessionId?: string | undefined;
-}, {
-    entries: {
-        at: string;
-        tier?: string | undefined;
-        inputTokens?: number | undefined;
-        outputTokens?: number | undefined;
-        cacheReadTokens?: number | undefined;
-        cacheCreationTokens?: number | undefined;
-    }[];
-    runId: string;
-    startedAt: string;
-    sessionId?: string | undefined;
-}>;
-export type UsageRecord = z.infer<typeof UsageRecordSchema>;
-/** The persisted store: a bounded, newest-last list of run records. */
-export declare const UsageFileSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    runs: z.ZodArray<z.ZodObject<{
-        /** Unique id for this run (one `session.send`). */
-        runId: z.ZodString;
-        /** Groups runs of one interactive session, so `--session` aggregates them. */
-        sessionId: z.ZodOptional<z.ZodString>;
-        /** ISO-8601 timestamp the run started. */
-        startedAt: z.ZodString;
-        entries: z.ZodArray<z.ZodObject<{
-            /** The routing tier (C.30) this request ran on; absent when routing is inert. */
-            tier: z.ZodOptional<z.ZodString>;
-            /** Provider-reported prompt tokens; `undefined` ⇔ no usage was reported. */
-            inputTokens: z.ZodOptional<z.ZodNumber>;
-            /** Provider-reported completion tokens; `undefined` ⇔ no usage was reported. */
-            outputTokens: z.ZodOptional<z.ZodNumber>;
-            /**
-             * Prompt-cache tokens READ from a warm cache (phase-A caching, Anthropic dev
-             * path). `undefined` ⇔ the provider doesn't cache / reported nothing (the
-             * cruxy gateway today) — never zero-filled. Optional, so older on-disk
-             * entries without the field still parse.
-             */
-            cacheReadTokens: z.ZodOptional<z.ZodNumber>;
-            /** Prompt-cache tokens WRITTEN this request (the ~1.25× write premium); same `undefined`-≠-0 rule. */
-            cacheCreationTokens: z.ZodOptional<z.ZodNumber>;
-            /** ISO-8601 timestamp the request completed. */
-            at: z.ZodString;
-        }, "strict", z.ZodTypeAny, {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-            cacheReadTokens?: number | undefined;
-            cacheCreationTokens?: number | undefined;
-        }, {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-            cacheReadTokens?: number | undefined;
-            cacheCreationTokens?: number | undefined;
-        }>, "many">;
-    }, "strict", z.ZodTypeAny, {
-        entries: {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-            cacheReadTokens?: number | undefined;
-            cacheCreationTokens?: number | undefined;
-        }[];
-        runId: string;
-        startedAt: string;
-        sessionId?: string | undefined;
-    }, {
-        entries: {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-            cacheReadTokens?: number | undefined;
-            cacheCreationTokens?: number | undefined;
-        }[];
-        runId: string;
-        startedAt: string;
-        sessionId?: string | undefined;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    version: 1;
-    runs: {
-        entries: {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-            cacheReadTokens?: number | undefined;
-            cacheCreationTokens?: number | undefined;
-        }[];
-        runId: string;
-        startedAt: string;
-        sessionId?: string | undefined;
-    }[];
-}, {
-    version: 1;
-    runs: {
-        entries: {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-            cacheReadTokens?: number | undefined;
-            cacheCreationTokens?: number | undefined;
-        }[];
-        runId: string;
-        startedAt: string;
-        sessionId?: string | undefined;
-    }[];
-}>;
-export type UsageFile = z.infer<typeof UsageFileSchema>;
-/**
- * A per-tier price, in the user's own currency, PER MILLION TOKENS. Chosen over
- * per-token so prices read the way LLM pricing is quoted and don't lose
- * precision to tiny floats. Configured by the user under `usage.prices.<tier>`;
- * cruxy ships NO prices (a bundled table would imply upstream identities and go
- * stale) — with none configured, cost is omitted entirely.
- */
-export interface TierPrice {
-    /** Price per 1,000,000 input tokens. */
-    input: number;
-    /** Price per 1,000,000 output tokens. */
-    output: number;
-}
-/**
- * Prices keyed by TIER ONLY (kavi/vaani/mira) — the type literally cannot name
- * an upstream model, so the U.8 gag holds by construction. Partial: any tier may
- * be unpriced (its cost is then omitted, tokens still shown).
- */
-export type PriceTable = Partial<Record<(typeof MODEL_TIERS)[number], TierPrice>>;
-/** Aggregated usage for one tier across the summarized runs. */
-export interface TierUsage {
-    tier: string;
-    /** Sum of KNOWN input tokens; `undefined` if no request on this tier reported usage. */
-    inputTokens?: number;
-    /** Sum of KNOWN output tokens; `undefined` if none reported. */
-    outputTokens?: number;
-    /** Sum of KNOWN cache-read tokens on this tier; `undefined` if none reported. */
-    cacheReadTokens?: number;
-    /** Sum of KNOWN cache-creation tokens on this tier; `undefined` if none reported. */
-    cacheCreationTokens?: number;
-    /** Requests attributed to this tier. */
-    requests: number;
-    /** How many of those reported no usage (surfaced, never silently dropped). */
-    requestsWithoutUsage: number;
-    /** Cost, ONLY when this tier is priced AND has known tokens; else omitted. */
-    cost?: number;
-}
-/** The aggregate over one or more runs — what the summary renderer consumes. */
-export interface UsageSummary {
-    perTier: TierUsage[];
-    /** Sum of KNOWN input tokens across all runs; `undefined` if none known. */
-    totalInputTokens?: number;
-    /** Sum of KNOWN output tokens across all runs; `undefined` if none known. */
-    totalOutputTokens?: number;
-    /**
-     * Sum of KNOWN cache-read tokens across all runs; `undefined` if none known
-     * (i.e. every request ran on a non-caching provider). Drives the `cached ↻N`
-     * figure, which is the observable proof that phase-A caching is working.
-     */
-    totalCacheReadTokens?: number;
-    /** Sum of KNOWN cache-creation tokens across all runs; `undefined` if none known. */
-    totalCacheCreationTokens?: number;
-    /** Sum of per-tier costs; `undefined` unless ≥1 tier was priced. */
-    totalCost?: number;
-    /** True iff at least one tier had a configured price (cost is shown). */
-    priced: boolean;
-    /** Currency label to prefix costs with; "" when the user configured none. */
-    currency: string;
-    /** Total requests across all runs that reported no usage (rendered visibly). */
-    requestsWithoutUsage: number;
-    /** Total requests across all runs. */
-    requests: number;
-    /** How many runs were aggregated. */
-    runCount: number;
-}

package/dist/utils/child-tree.d.ts

@@ -1,33 +0,0 @@
-/**
- * The process-EXIT backstop for long-lived child trees (C.12 LSP servers, C.27
- * MCP servers). The platform-aware spawn/kill primitives themselves now live in
- * {@link ./process-tree.js} — {@link killTree} is re-exported here unchanged so
- * existing LSP/MCP importers keep their import path, and so this backstop and
- * those transports reap trees the SAME way on every platform (negative-PID
- * `SIGKILL` on POSIX, `taskkill /T /F` on win32 — no more orphaned grandchildren
- * on Windows).
- *
- * A per-session graceful shutdown covers the normal path, but a hard exit
- * (Ctrl-C, an uncaught throw) would otherwise orphan these trees. So every live
- * child's pid is tracked in one process-wide set and force-killed on teardown.
- * Handlers are installed ONCE, lazily, on the first registration — so unit tests
- * that never spawn a real process never install them.
- *
- * This module is deliberately transport-agnostic: LSP (Content-Length framing)
- * and MCP (newline-delimited JSON) share the SAME backstop, so `killTrackedTrees`
- * on exit reaps both and there is a single source of truth for "no orphans".
- */
-import { killTree } from "./process-tree.js";
-export { killTree };
-/**
- * Force-kill the process group of every tracked-but-not-yet-shut-down child,
- * then forget them. This is exactly what the `exit`/`SIGINT`/`SIGTERM`/`SIGHUP`
- * handlers run — the last line against orphaned server trees on a hard exit.
- * Exported so it is directly testable without raising real process signals.
- * Idempotent: a second call is a no-op.
- */
-export declare function killTrackedTrees(): void;
-/** Number of child trees currently tracked by the exit backstop (for tests). */
-export declare function trackedTreeCount(): number;
-/** Track a live child for the exit backstop; returns a deregister callback. */
-export declare function registerForCleanup(pid: number | undefined): () => void;

package/dist/utils/git.d.ts

@@ -1,17 +0,0 @@
-/**
- * Branch name plus the raw `git status --porcelain` text for `cwd`, or `null`
- * when it isn't a git repository (or git is unavailable). Backs the `git_status`
- * tool, which surfaces the porcelain output to the model.
- */
-export declare function getGitStatus(cwd: string): {
-    branch: string;
-    status: string;
-} | null;
-/**
- * Compact git context for the system prompt: current branch and whether the
- * working tree has uncommitted changes. `null` when not a repo / git missing.
- */
-export declare function getGitInfo(cwd: string): {
-    branch: string;
-    dirty: boolean;
-} | null;

package/dist/utils/logger.d.ts

@@ -1,18 +0,0 @@
-export declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "silent"];
-export type LogLevel = (typeof LOG_LEVELS)[number];
-declare class Logger {
-    private level;
-    /** Diagnostics go to stderr, so the theme resolves against stderr's color. */
-    private readonly theme;
-    setLevel(level: LogLevel): void;
-    getLevel(): LogLevel;
-    private enabled;
-    debug(...args: unknown[]): void;
-    info(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-    /** Primary user-facing output — always written to stdout. */
-    print(...args: unknown[]): void;
-}
-export declare const logger: Logger;
-export {};

package/dist/utils/process-tree.d.ts

@@ -1,16 +0,0 @@
-import { type ChildProcess, type SpawnOptions } from "node:child_process";
-/**
- * Spawn a child as the head of a killable process tree, applying the
- * platform-correct grouping options on top of the caller's own (`shell`, `cwd`,
- * `stdio`, `env`, …). Any `detached`/`windowsHide` the caller passes is
- * overridden — grouping is this module's responsibility, not the call site's.
- */
-export declare function spawnTree(command: string, args?: readonly string[], options?: SpawnOptions): ChildProcess;
-/**
- * Kill a child's ENTIRE process tree — the child and every descendant it
- * spawned. POSIX: negative-PID `SIGKILL` targets the process group created by
- * {@link spawnTree}'s `detached`. win32: `taskkill /PID <pid> /T /F` walks the
- * OS tree (`/T`) and force-terminates it (`/F`). Fire-and-forget and
- * error-swallowing on both paths — the tree may already be gone.
- */
-export declare function killTree(pid: number | undefined): void;

package/dist/vcs/auth.d.ts

@@ -1,22 +0,0 @@
-/**
- * Resolve a forge token (C.15). The chain is, in order:
- *   1. `GITHUB_TOKEN`
- *   2. `GH_TOKEN`
- *   3. `gh auth token` (if the GitHub CLI is installed and logged in)
- *   4. fail loud — {@link forgeAuth} (`CRUXY_E_FORGE_AUTH`)
- *
- * We **never** prompt for, store, or persist a token: it's read from the
- * environment / `gh` on every run, exactly like provider API keys.
- */
-/** Injection seams so the chain is testable without real env / a real `gh`. */
-export interface ForgeAuthDeps {
-    /** Environment to read tokens from (defaults to `process.env`). */
-    env?: NodeJS.ProcessEnv;
-    /** Run `gh auth token`, returning the token or `null`. Defaults to the CLI. */
-    ghToken?: () => string | null;
-}
-/**
- * Resolve a forge token or throw {@link forgeAuth}. `host` is only used to make
- * the error message specific.
- */
-export declare function resolveForgeToken(deps?: ForgeAuthDeps, host?: string): string;

package/dist/vcs/generate.d.ts

@@ -1,74 +0,0 @@
-import type { Provider } from "@cruxy/sdk";
-import type { GeneratedContent } from "./types.js";
-/**
- * Turn a diff + session context into the PR publish content (C.15): a
- * conventional-commit subject, a structured body, a branch name, and the PR
- * title/body. The repo's commit rules (the C.18 git-commit skill + the
- * commitlint scope list) are honored two ways: they're handed to the LLM in the
- * prompt, **and** every field is run through deterministic normalizers so the
- * lowercase-subject rule (and scope allow-list) hold even if the model slips.
- *
- * Secrets never leave: the diff is redacted before the LLM sees it, and the
- * generated bodies are redacted again (defense-in-depth).
- */
-/** Conventional-commit types accepted by `@commitlint/config-conventional`. */
-export declare const CONVENTIONAL_TYPES: readonly ["feat", "fix", "chore", "docs", "refactor", "test", "perf", "build", "ci", "style", "revert"];
-export interface GenerateInput {
-    /** The change set to summarize (already from `diffAgainst`). */
-    diff: string;
-    /** The PR base branch. */
-    base: string;
-    /** The branch the change is on, if already a feature branch. */
-    currentBranch?: string;
-    /** A short summary of what the agent did this session, if available. */
-    sessionSummary?: string;
-    /** commitlint scope allow-list; empty ⇒ no scope constraint. */
-    scopes: string[];
-    /** The git-commit SKILL.md body, embedded into the LLM prompt verbatim. */
-    skillBody?: string;
-    /** Caller-supplied title (e.g. the agent's), normalized rather than generated. */
-    title?: string;
-    /** Caller-supplied body. */
-    body?: string;
-}
-/** Strip anything that looks like a credential from `text`. */
-export declare function redactSecrets(text: string): string;
-/**
- * Force `raw` into a valid conventional-commit subject: a known `type`, an
- * allow-listed scope (dropped if it isn't), a **lowercase** first word, no
- * trailing period, clamped to 72 chars. This is the deterministic guarantee that
- * the commitlint `subject-case` + `scope-enum` rules pass.
- */
-export declare function normalizeSubject(raw: string, scopes?: string[]): string;
-/** A safe branch name `type/slug` derived from a conventional subject. */
-export declare function slugifyBranch(subject: string): string;
-/** Assemble a structured PR body: what changed · why · verification. */
-export declare function assembleBody(parts: {
-    what: string;
-    why?: string;
-    verification?: string;
-}): string;
-/**
- * Build the publish content deterministically (used by the `create_pull_request`
- * tool, where the agent itself authored the title/body). Missing fields are
- * derived; every field is still normalized + redacted.
- */
-export declare function fillContent(input: GenerateInput): GeneratedContent;
-/**
- * Generate publish content from the diff with the model, honoring the commit
- * rules, then normalize + redact. Resilient: if the model's reply isn't the
- * expected JSON, the first line becomes the subject and the rest the body.
- */
-export declare function generateWithLlm(provider: Provider, input: GenerateInput, opts?: {
-    model?: string;
-}): Promise<GeneratedContent>;
-interface ParsedGenerated {
-    branchName?: string;
-    commitSubject?: string;
-    commitBody?: string;
-    prTitle?: string;
-    prBody?: string;
-}
-/** Parse the model reply: a JSON object if present, else first-line/rest. */
-export declare function parseGenerated(text: string): ParsedGenerated;
-export {};

package/dist/vcs/git.d.ts

@@ -1,60 +0,0 @@
-export interface GitResult {
-    readonly ok: boolean;
-    readonly stdout: string;
-    readonly stderr: string;
-    readonly code: number | null;
-}
-/** Run `git <args>` in `cwd`, capturing stdout/stderr/exit. Never throws. */
-export declare function runGitCapture(args: string[], cwd: string): GitResult;
-/**
- * The absolute path of the git working tree that contains `cwd` (its
- * `--show-toplevel`), or `null` when `cwd` is not inside a git repository. Git
- * returns a canonical (symlink-resolved) path. Used by the C.26 cross-root guard
- * to detect two declared roots that share one repository (a commit for one would
- * `git add -A` the other's changes too).
- */
-export declare function gitToplevel(cwd: string): string | null;
-/** The current branch name, or `null` when detached / not a repo. */
-export declare function currentBranch(cwd: string): string | null;
-/** The default set of branch names cruxy will never write to directly. */
-export declare const DEFAULT_PROTECTED_BRANCHES: readonly ["main", "master"];
-/**
- * Is `branch` protected? The built-in `main`/`master` plus any names from config.
- * Case-insensitive so `Main`/`MASTER` are caught too.
- */
-export declare function isProtectedBranch(branch: string, extra?: readonly string[]): boolean;
-export interface EnsureBranchResult {
-    /** The branch we ended up on (always a non-protected branch). */
-    readonly branch: string;
-    /** Whether we created/switched (true) or were already on a feature branch. */
-    readonly switched: boolean;
-}
-/**
- * Guarantee we're on a non-protected feature branch before any commit/push. If
- * already on a feature branch, stay there. If on a protected branch, switch to
- * `desired` (creating it if needed). Throws if `desired` is itself protected.
- */
-export declare function ensureFeatureBranch(cwd: string, desired: string, protectedExtra?: readonly string[]): EnsureBranchResult;
-/** Stage every change in the working tree (`git add -A`). */
-export declare function stageAll(cwd: string): void;
-/** Whether the working tree (staged or not) has any changes to commit. */
-export declare function hasChanges(cwd: string): boolean;
-/**
- * Commit the staged changes with a conventional message. Refuses on a protected
- * branch (last-line guard) and **never** passes `--no-verify`, so the commitlint
- * `commit-msg` hook runs. Subject and body go as separate `-m` flags.
- */
-export declare function commit(cwd: string, subject: string, body: string, protectedExtra?: readonly string[]): void;
-/**
- * Push `branch` to `origin`, setting upstream. **Never** `--force`, **never**
- * `--no-verify` — the pre-push hook (build · typecheck · lint · test + main
- * guard) runs and a failure is surfaced verbatim. Refuses on a protected branch.
- */
-export declare function push(cwd: string, branch: string, protectedExtra?: readonly string[]): void;
-/**
- * The change set for content generation: the working-tree diff relative to
- * `base` (covers committed-on-branch *and* uncommitted edits), plus the names of
- * untracked files (which a plain `git diff` omits). Falls back to the diff vs
- * `HEAD` when `base` isn't reachable (shallow clone / brand-new repo).
- */
-export declare function diffAgainst(cwd: string, base: string): string;

package/dist/vcs/github.d.ts

@@ -1,50 +0,0 @@
-import type { ForgeProvider, PullRequestResult, PullRequestSpec, RepoIdentity, RepoInfo } from "./types.js";
-/**
- * GitHub implementation of {@link ForgeProvider} (C.15) — the only forge that
- * ships today. It talks to the REST API directly (no octokit dependency) and
- * keeps `fetch` injectable for tests. Everything GitHub-specific lives here;
- * nothing above {@link ForgeProvider} knows it's GitHub.
- */
-export interface GitHubProviderOptions {
-    /** The resolved forge token (see `auth.ts`). */
-    token: string;
-    /** Injected fetch (tests / advanced); defaults to global `fetch`. */
-    fetchImpl?: typeof fetch;
-}
-export declare class GitHubProvider implements ForgeProvider {
-    readonly id = "github";
-    private readonly token;
-    private readonly fetchImpl;
-    constructor(opts: GitHubProviderOptions);
-    /**
-     * The LOCAL half of {@link getRepoInfo}: read `origin` and parse it, no network.
-     * Shared by the full lookup and by the Step-4 wrong-repo re-check so both derive
-     * the target from the exact same rule.
-     */
-    resolveRepoIdentity(cwd: string): RepoIdentity;
-    getRepoInfo(cwd: string): Promise<RepoInfo>;
-    createPullRequest(repo: RepoInfo, spec: PullRequestSpec): Promise<PullRequestResult>;
-    /** Look up an open PR for `owner:head`, or `null` if there isn't one. */
-    private findOpenPr;
-    private fetchDefaultBranch;
-    /** Issue an authenticated REST call, resolving the API base from the host. */
-    private api;
-}
-/**
- * Parse a git remote URL into `{ host, owner, repo }`, supporting the https,
- * `scp`-style ssh, and `ssh://` forms. Returns `null` for anything we can't
- * confidently parse as `host/owner/repo`.
- */
-export declare function parseRemote(url: string): {
-    host: string;
-    owner: string;
-    repo: string;
-} | null;
-/**
- * Construct the forge provider for a token. GitHub today; the GitLab/Bitbucket
- * branch slots in here later (e.g. switch on a configured provider id) without
- * touching the orchestrator.
- */
-export declare function createForgeProvider(token: string, opts?: {
-    fetchImpl?: typeof fetch;
-}): ForgeProvider;

package/dist/vcs/guidance.d.ts

@@ -1,20 +0,0 @@
-/**
- * The repo's commit conventions, gathered best-effort so PR generation honors
- * them automatically (C.15): the C.18 git-commit skill body and the commitlint
- * scope allow-list. Both are optional — a repo may have neither — so every lookup
- * degrades to a sensible empty default rather than failing the PR flow.
- */
-export interface CommitGuidance {
-    /** The git-commit SKILL.md body, embedded verbatim into the LLM prompt. */
-    skillBody?: string;
-    /** commitlint `scope-enum` values; empty ⇒ no scope constraint. */
-    scopes: string[];
-}
-/** Load the git-commit skill body + commitlint scopes for `cwd`. Never throws. */
-export declare function loadCommitGuidance(cwd: string): Promise<CommitGuidance>;
-/**
- * Extract the `scope-enum` allow-list from a repo's commitlint config. Supports
- * the JS/CJS module forms (imported) and JSON. Any failure ⇒ `[]` (no
- * constraint), so a malformed or absent config never blocks a PR.
- */
-export declare function loadCommitlintScopes(cwd: string): Promise<string[]>;

package/dist/vcs/index.d.ts

@@ -1,7 +0,0 @@
-export * from "./types.js";
-export * from "./git.js";
-export * from "./github.js";
-export * from "./auth.js";
-export * from "./generate.js";
-export * from "./guidance.js";
-export * from "./service.js";

package/dist/vcs/service.d.ts

@@ -1,61 +0,0 @@
-import type { ApprovalDecision } from "../approval/types.js";
-import type { CruxyConfig } from "../config/index.js";
-import type { ApproveAction } from "../tools/types.js";
-import type { ForgeProvider, GeneratedContent } from "./types.js";
-/**
- * The PR-publish orchestrator (C.15): ensure a feature branch → commit → push →
- * open PR, with the **entire** plan gated by one U.3 approval. Nothing mutates
- * before the user approves; a rejection aborts cleanly with no commit or push.
- *
- * The forge and the content generator are injected, so both call sites — the
- * `create_pull_request` tool (deterministic fill) and the `cruxy pr` command
- * (LLM generation) — share this exact flow.
- */
-/** Produce the publish content for a change set (LLM or deterministic). */
-export type GenerateContent = (input: {
-    diff: string;
-    base: string;
-    currentBranch?: string;
-    title?: string;
-    body?: string;
-}) => Promise<GeneratedContent>;
-export interface PrServiceDeps {
-    cwd: string;
-    /**
-     * The name of the declared workspace root this PR acts in (C.26 Step 4). It is
-     * the exact root the caller selected — the U.3 attribution and the wrong-repo
-     * error name it verbatim, rather than re-deriving a basename from `cwd`. Defaults
-     * to `basename(cwd)` for callers that don't select a root (the single-root `cruxy
-     * pr` command), which is byte-identical to the pre-Step-4 attribution.
-     */
-    rootName?: string;
-    config: CruxyConfig;
-    forge: ForgeProvider;
-    generate: GenerateContent;
-    /** The U.3 gate (the same capability tools receive as `ctx.requestApproval`). */
-    requestApproval: (action: ApproveAction) => Promise<ApprovalDecision>;
-}
-export interface OpenPrOptions {
-    /** Override the base branch (else config.git.defaultBase → repo default → main). */
-    base?: string;
-    /** Caller-supplied PR title (normalized, not generated). */
-    title?: string;
-    /** Caller-supplied PR body. */
-    body?: string;
-    draft?: boolean;
-}
-export type OpenPrOutcome = {
-    approved: false;
-    feedback?: string;
-} | {
-    approved: true;
-    url: string;
-    number: number;
-    branch: string;
-    base: string;
-    alreadyExists: boolean;
-};
-/** Build a PR service from its dependencies. */
-export declare function createPrService(deps: PrServiceDeps): {
-    openPullRequest: (opts?: OpenPrOptions) => Promise<OpenPrOutcome>;
-};