@cad0p/pi-steering 0.1.0

package/dist/compat.js

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: MIT
+// Part of pi-steering.
+/**
+ * Error thrown when the input JSON uses a feature the v1 → v2 helper
+ * can't represent. Carries a `path` pointing at the offending location
+ * (e.g. `rules[2].when.branch`) so callers can point the user at the
+ * rule to rewrite in TypeScript.
+ */
+export class FromJSONError extends Error {
+    path;
+    constructor(message, path) {
+        super(`${message} (at ${path})`);
+        this.name = "FromJSONError";
+        this.path = path;
+    }
+}
+/** Narrow `unknown` to a plain (non-array) object. */
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Convert v1 JSON into a v2 {@link SteeringConfig}.
+ *
+ * The input is typed `unknown` deliberately — this helper accepts
+ * whatever came out of `JSON.parse`, validates the shape, and throws
+ * {@link FromJSONError} on anything it can't represent.
+ */
+export function fromJSON(json) {
+    if (!isPlainObject(json)) {
+        throw new FromJSONError("expected a JSON object at the top level", "<root>");
+    }
+    // Pre-flight: loudly reject v2-only keys that shouldn't appear in
+    // v1 JSON. If a user lands here by mistake (e.g. calling fromJSON
+    // on an already-v2 object), we'd rather tell them than silently
+    // drop their plugins / observers.
+    for (const forbidden of [
+        "plugins",
+        "observers",
+        "disablePlugins",
+        "disabledPlugins",
+        "disabledRules",
+        "disableDefaults",
+    ]) {
+        if (forbidden in json) {
+            throw new FromJSONError(`JSON config cannot express \`${forbidden}\`; ` +
+                `author that configuration directly in TypeScript instead`, `<root>.${forbidden}`);
+        }
+    }
+    const out = {};
+    if ("disable" in json) {
+        const disable = json["disable"];
+        if (!Array.isArray(disable) ||
+            !disable.every((x) => typeof x === "string")) {
+            throw new FromJSONError("`disable` must be a string array", "<root>.disable");
+        }
+        // v1 JSON's `disable` → v2 TS `disabledRules`. The JSON key is
+        // preserved for legacy on-disk configs; the TS shape uses the
+        // past-participle form.
+        out.disabledRules = [...disable];
+    }
+    if ("defaultNoOverride" in json) {
+        const v = json["defaultNoOverride"];
+        if (typeof v !== "boolean") {
+            throw new FromJSONError("`defaultNoOverride` must be a boolean", "<root>.defaultNoOverride");
+        }
+        out.defaultNoOverride = v;
+    }
+    if ("rules" in json) {
+        const rules = json["rules"];
+        if (!Array.isArray(rules)) {
+            throw new FromJSONError("`rules` must be an array", "<root>.rules");
+        }
+        out.rules = rules.map((rule, i) => convertRule(rule, `<root>.rules[${i}]`));
+    }
+    return out;
+}
+/** Convert a single v1 JSON rule, scoping errors with `path`. */
+function convertRule(raw, path) {
+    if (!isPlainObject(raw)) {
+        throw new FromJSONError("rule must be an object", path);
+    }
+    // Required: name, tool, field, pattern, reason.
+    const name = raw["name"];
+    if (typeof name !== "string" || name.length === 0) {
+        throw new FromJSONError("`name` must be a non-empty string", `${path}.name`);
+    }
+    const tool = raw["tool"];
+    if (tool !== "bash" && tool !== "write" && tool !== "edit") {
+        throw new FromJSONError("`tool` must be one of 'bash' | 'write' | 'edit'", `${path}.tool`);
+    }
+    const field = raw["field"];
+    if (field !== "command" && field !== "path" && field !== "content") {
+        throw new FromJSONError("`field` must be one of 'command' | 'path' | 'content'", `${path}.field`);
+    }
+    // Validate the (tool, field) combination per the discriminated
+    // Rule union: bash rules test against `command`; write / edit
+    // rules test against `path` or `content`.
+    if (tool === "bash" && field !== "command") {
+        throw new FromJSONError(`bash rules must use \`field: "command"\` (got "${field}")`, `${path}.field`);
+    }
+    if ((tool === "write" || tool === "edit") && field === "command") {
+        throw new FromJSONError(`${tool} rules must use \`field: "path"\` or \`field: "content"\` ` +
+            `(got "command")`, `${path}.field`);
+    }
+    const pattern = raw["pattern"];
+    if (typeof pattern !== "string") {
+        throw new FromJSONError("JSON rules must use a string `pattern` (v2 accepts RegExp in TS)", `${path}.pattern`);
+    }
+    const reason = raw["reason"];
+    if (typeof reason !== "string") {
+        throw new FromJSONError("`reason` must be a string", `${path}.reason`);
+    }
+    const rule = tool === "bash"
+        ? { name, tool, field: "command", pattern, reason }
+        : {
+            name,
+            tool,
+            // Narrowed by the (tool, field) check above.
+            field: field,
+            pattern,
+            reason,
+        };
+    // Optional: requires / unless (string patterns only).
+    if ("requires" in raw) {
+        const v = raw["requires"];
+        if (typeof v !== "string") {
+            throw new FromJSONError("JSON rules must use string `requires` (functions aren't JSON-expressible)", `${path}.requires`);
+        }
+        rule.requires = v;
+    }
+    if ("unless" in raw) {
+        const v = raw["unless"];
+        if (typeof v !== "string") {
+            throw new FromJSONError("JSON rules must use string `unless` (functions aren't JSON-expressible)", `${path}.unless`);
+        }
+        rule.unless = v;
+    }
+    // Optional: noOverride.
+    if ("noOverride" in raw) {
+        const v = raw["noOverride"];
+        if (typeof v !== "boolean") {
+            throw new FromJSONError("`noOverride` must be a boolean", `${path}.noOverride`);
+        }
+        rule.noOverride = v;
+    }
+    // Optional: when. V1 JSON supports only `when.cwd` (string pattern).
+    // Every other key under `when` is plugin-specific and can't be
+    // expressed in JSON.
+    if ("when" in raw) {
+        rule.when = convertWhen(raw["when"], `${path}.when`);
+    }
+    // V1 JSON has no `observer` field — observers are v2-only. But if
+    // someone hand-edits `observer: "name"` into their JSON, warn loudly.
+    if ("observer" in raw) {
+        throw new FromJSONError("JSON rules cannot reference observers; observers are v2-only (TS)", `${path}.observer`);
+    }
+    return rule;
+}
+/** Convert the v1 `when` object into a v2 {@link WhenClause}. */
+function convertWhen(raw, path) {
+    if (!isPlainObject(raw)) {
+        throw new FromJSONError("`when` must be an object", path);
+    }
+    const out = {};
+    for (const key of Object.keys(raw)) {
+        if (key !== "cwd") {
+            throw new FromJSONError(`JSON config cannot express \`when.${key}\`; ` +
+                `plugin-registered predicates and \`when.not\` / \`when.condition\` are v2-only (TS)`, `${path}.${key}`);
+        }
+    }
+    if ("cwd" in raw) {
+        const v = raw["cwd"];
+        if (typeof v !== "string") {
+            throw new FromJSONError("JSON `when.cwd` must be a string pattern", `${path}.cwd`);
+        }
+        out.cwd = v;
+    }
+    return out;
+}
+//# sourceMappingURL=compat.js.map

package/dist/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.js","sourceRoot":"","sources":["../src/compat.ts"],"names":[],"mappings":"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"}

package/dist/defaults.d.ts

@@ -0,0 +1,61 @@
+export declare const DEFAULT_RULES: readonly [{
+    readonly name: "no-force-push";
+    readonly tool: "bash";
+    readonly field: "command";
+    readonly pattern: "^git\\b(?:\\s+-{1,2}[A-Za-z]\\S*(?:\\s+\\S+)?)*\\s+push\\b.*(?:--force(?!-with-lease)|\\s-f(?:\\s|$))";
+    readonly reason: "Force push rewrites remote history and can destroy teammates' work. Use `git push --force-with-lease` if you must, or create a new commit instead.";
+}, {
+    readonly name: "no-hard-reset";
+    readonly tool: "bash";
+    readonly field: "command";
+    readonly pattern: "^git\\b(?:\\s+-{1,2}[A-Za-z]\\S*(?:\\s+\\S+)?)*\\s+reset\\s+--hard\\b";
+    readonly reason: "Hard reset discards uncommitted changes permanently. Use `git stash` to save work first, or `git reset --soft` to keep changes staged.";
+}, {
+    readonly name: "no-rm-rf-slash";
+    readonly tool: "bash";
+    readonly field: "command";
+    readonly pattern: "^rm\\b(?=.*(?:-[A-Za-z]*[rR][A-Za-z]*|--recursive))(?=.*(?:-[A-Za-z]*f[A-Za-z]*|--force)).*\\s/(?:\\s|$)";
+    readonly reason: "Recursive force-delete from root is catastrophic and irreversible. Specify a safe path (e.g. a subdirectory of the project or a temp dir).";
+    readonly noOverride: true;
+}, {
+    readonly name: "no-long-running-commands";
+    readonly tool: "bash";
+    readonly field: "command";
+    readonly pattern: "^(?:npm\\s+(?:run\\s+dev|start)|yarn\\s+(?:dev|start)|pnpm\\s+(?:run\\s+)?(?:dev|start)|npx\\s+.*--watch|webpack\\s+(?:--watch|serve)|jest\\s+--watch|nodemon\\b|tsc\\s+--watch|vite(?:\\s+(?:dev|serve|preview))?(?!\\s+[A-Za-z])|astro\\s+(?:dev|preview)|next\\s+dev|deno\\s+task\\s+(?:dev|start|serve)|bun\\s+(?:dev|run\\s+dev))\\b";
+    readonly reason: "Long-running dev servers and watchers block the agent loop. Ask the user to run it manually in another terminal, or use a background-process tool. Representative — add your own via `.pi/steering.ts` if a framework isn't listed here.";
+}];
+/**
+ * Default plugins shipped by the package.
+ *
+ * Deliberately empty since the v0.1.x monorepo split: the git plugin
+ * (`pi-steering/plugins/git`) is OPT-IN, not default-on. Users who
+ * want the `branch` / `upstream` / `commitsAhead` / `hasStagedChanges`
+ * / `isClean` / `remote` predicates, the `no-main-commit` /
+ * `no-main-commit-github` rules, the branch tracker, or the `cwd.git`
+ * tracker extension must declare it explicitly:
+ *
+ * ```ts
+ * import gitPlugin from "@cad0p/pi-steering/plugins/git";
+ * export default defineConfig({ plugins: [gitPlugin] });
+ * ```
+ *
+ * Declaring the plugin explicitly is what gives `defineConfig`'s
+ * generics the rule / plugin name unions for typo-checking on
+ * `disabledRules` / `disabledPlugins` — an undeclared plugin's rule
+ * names are NOT in the inferred union, so typos surface as compile
+ * errors instead of silent no-ops. Runtime defaults and type-level
+ * visibility must not diverge; an empty default list is the only way
+ * to guarantee they can't.
+ *
+ * Rationale for opt-in (reverses the v0.1.0 D1 default-on decision):
+ * git discipline rules are opinionated project policy, not universal
+ * safety rails — `DEFAULT_RULES` (domain-agnostic rails like
+ * `no-force-push`, `no-rm-rf-slash`) remains default-on; domain
+ * plugins opt in.
+ *
+ * The count lock in `defaults.test.ts` guards this list: any addition
+ * to the default plugin list is a deliberate ship-surface change and
+ * must update the assertion explicitly.
+ */
+export declare const DEFAULT_PLUGINS: readonly [];
+//# sourceMappingURL=defaults.d.ts.map

package/dist/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../src/defaults.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;EA4EU,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,eAAe,aAA0C,CAAC"}

package/dist/defaults.js

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: MIT
+// Part of pi-steering.
+export const DEFAULT_RULES = [
+    // `as const satisfies readonly Rule[]` (vs. `: Rule[]`) preserves
+    // each rule's `name` literal through to `defaults` consumers. The
+    // type unions in `define-config.ts` (`DefaultRuleName`,
+    // `AllRuleNames`) project off `(typeof DEFAULT_RULES)[number]["name"]`
+    // — a bare `Rule[]` annotation widens those literals to `string`
+    // and silently disables typo-detection on `disabledRules`.
+    {
+        name: "no-force-push",
+        tool: "bash",
+        field: "command",
+        // Block `git push --force` / `-f`, allow `--force-with-lease`.
+        // Anchored so `echo 'git push --force'` (basename=echo) is NOT
+        // flagged. The pre-subcommand flag slot
+        // `(?:\s+-{1,2}[A-Za-z]\S*(?:\s+\S+)?)*` allows short and long
+        // git-flags before the subcommand:
+        //   - `git -C /path push --force`
+        //   - `git -c key=val push --force`
+        //   - `git --git-dir=/x push --force`
+        // All three are silent bypasses with a plain `^git\s+push` anchor.
+        //
+        // Known limit: this pattern over-matches on
+        // `git log --grep="push --force"` because `--grep=push` is a
+        // single token that still satisfies `\bpush\b`. Real agents don't
+        // emit that; if it becomes a problem we'll move to args-array
+        // matching.
+        pattern: "^git\\b(?:\\s+-{1,2}[A-Za-z]\\S*(?:\\s+\\S+)?)*\\s+push\\b.*(?:--force(?!-with-lease)|\\s-f(?:\\s|$))",
+        reason: "Force push rewrites remote history and can destroy teammates' work. Use `git push --force-with-lease` if you must, or create a new commit instead.",
+    },
+    {
+        name: "no-hard-reset",
+        tool: "bash",
+        field: "command",
+        // Same pre-subcommand flag broadening as `no-force-push` so
+        // `git -C /other reset --hard` and `git -c key=val reset --hard`
+        // are also caught.
+        pattern: "^git\\b(?:\\s+-{1,2}[A-Za-z]\\S*(?:\\s+\\S+)?)*\\s+reset\\s+--hard\\b",
+        reason: "Hard reset discards uncommitted changes permanently. Use `git stash` to save work first, or `git reset --soft` to keep changes staged.",
+    },
+    {
+        name: "no-rm-rf-slash",
+        tool: "bash",
+        field: "command",
+        // rm with recursive AND force flags in any form, operating on `/`.
+        // Uses two independent lookaheads so separated flags (`-r -f`),
+        // long-form flags (`--recursive --force`), mixed case (`-Rf`),
+        // and reversed order (`-fr`) are all caught. Anchored to the
+        // basename so `echo 'rm -rf /'` (basename=echo) is NOT flagged.
+        pattern: "^rm\\b(?=.*(?:-[A-Za-z]*[rR][A-Za-z]*|--recursive))(?=.*(?:-[A-Za-z]*f[A-Za-z]*|--force)).*\\s/(?:\\s|$)",
+        reason: "Recursive force-delete from root is catastrophic and irreversible. Specify a safe path (e.g. a subdirectory of the project or a temp dir).",
+        // HARD block — inherent destructiveness, no override possible.
+        // Explicit `noOverride: true` guarantees this even when a layer
+        // sets `defaultNoOverride: false`.
+        noOverride: true,
+    },
+    {
+        name: "no-long-running-commands",
+        tool: "bash",
+        field: "command",
+        // Covers npm / yarn / pnpm dev + start, npx --watch, webpack dev
+        // modes, jest / tsc --watch, nodemon, and the modern
+        // bundler/runtime ecosystem (vite, astro, next dev, deno task
+        // dev/start/serve, bun dev). Representative, not exhaustive —
+        // consumers with other watchers should add them via their own
+        // `.pi/steering.ts`.
+        pattern: "^(?:npm\\s+(?:run\\s+dev|start)|yarn\\s+(?:dev|start)|pnpm\\s+(?:run\\s+)?(?:dev|start)|npx\\s+.*--watch|webpack\\s+(?:--watch|serve)|jest\\s+--watch|nodemon\\b|tsc\\s+--watch|vite(?:\\s+(?:dev|serve|preview))?(?!\\s+[A-Za-z])|astro\\s+(?:dev|preview)|next\\s+dev|deno\\s+task\\s+(?:dev|start|serve)|bun\\s+(?:dev|run\\s+dev))\\b",
+        reason: "Long-running dev servers and watchers block the agent loop. Ask the user to run it manually in another terminal, or use a background-process tool. Representative — add your own via `.pi/steering.ts` if a framework isn't listed here.",
+    },
+];
+/**
+ * Default plugins shipped by the package.
+ *
+ * Deliberately empty since the v0.1.x monorepo split: the git plugin
+ * (`pi-steering/plugins/git`) is OPT-IN, not default-on. Users who
+ * want the `branch` / `upstream` / `commitsAhead` / `hasStagedChanges`
+ * / `isClean` / `remote` predicates, the `no-main-commit` /
+ * `no-main-commit-github` rules, the branch tracker, or the `cwd.git`
+ * tracker extension must declare it explicitly:
+ *
+ * ```ts
+ * import gitPlugin from "@cad0p/pi-steering/plugins/git";
+ * export default defineConfig({ plugins: [gitPlugin] });
+ * ```
+ *
+ * Declaring the plugin explicitly is what gives `defineConfig`'s
+ * generics the rule / plugin name unions for typo-checking on
+ * `disabledRules` / `disabledPlugins` — an undeclared plugin's rule
+ * names are NOT in the inferred union, so typos surface as compile
+ * errors instead of silent no-ops. Runtime defaults and type-level
+ * visibility must not diverge; an empty default list is the only way
+ * to guarantee they can't.
+ *
+ * Rationale for opt-in (reverses the v0.1.0 D1 default-on decision):
+ * git discipline rules are opinionated project policy, not universal
+ * safety rails — `DEFAULT_RULES` (domain-agnostic rails like
+ * `no-force-push`, `no-rm-rf-slash`) remains default-on; domain
+ * plugins opt in.
+ *
+ * The count lock in `defaults.test.ts` guards this list: any addition
+ * to the default plugin list is a deliberate ship-surface change and
+ * must update the assertion explicitly.
+ */
+export const DEFAULT_PLUGINS = [];
+//# sourceMappingURL=defaults.js.map

package/dist/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../src/defaults.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,uBAAuB;AAmCvB,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,kEAAkE;IAClE,kEAAkE;IAClE,wDAAwD;IACxD,uEAAuE;IACvE,iEAAiE;IACjE,2DAA2D;IAC3D;QACE,IAAI,EAAE,eAAe;QACrB,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,SAAS;QAChB,+DAA+D;QAC/D,+DAA+D;QAC/D,wCAAwC;QACxC,+DAA+D;QAC/D,mCAAmC;QACnC,kCAAkC;QAClC,oCAAoC;QACpC,sCAAsC;QACtC,mEAAmE;QACnE,EAAE;QACF,4CAA4C;QAC5C,6DAA6D;QAC7D,kEAAkE;QAClE,8DAA8D;QAC9D,YAAY;QACZ,OAAO,EACL,uGAAuG;QACzG,MAAM,EACJ,oJAAoJ;KACvJ;IACD;QACE,IAAI,EAAE,eAAe;QACrB,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,SAAS;QAChB,4DAA4D;QAC5D,iEAAiE;QACjE,mBAAmB;QACnB,OAAO,EACL,uEAAuE;QACzE,MAAM,EACJ,wIAAwI;KAC3I;IACD;QACE,IAAI,EAAE,gBAAgB;QACtB,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,SAAS;QAChB,mEAAmE;QACnE,gEAAgE;QAChE,+DAA+D;QAC/D,6DAA6D;QAC7D,gEAAgE;QAChE,OAAO,EACL,0GAA0G;QAC5G,MAAM,EACJ,4IAA4I;QAC9I,+DAA+D;QAC/D,gEAAgE;QAChE,mCAAmC;QACnC,UAAU,EAAE,IAAI;KACjB;IACD;QACE,IAAI,EAAE,0BAA0B;QAChC,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,SAAS;QAChB,iEAAiE;QACjE,qDAAqD;QACrD,8DAA8D;QAC9D,8DAA8D;QAC9D,8DAA8D;QAC9D,qBAAqB;QACrB,OAAO,EACL,2UAA2U;QAC7U,MAAM,EACJ,0OAA0O;KAC7O;CACiC,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAuC,CAAC"}

package/dist/define-config.d.ts

@@ -0,0 +1,235 @@
+/**
+ * `defineConfig` — compile-time-typed config builder.
+ *
+ * Two supported authoring styles per the accepted ADR ("Design →
+ * `defineConfig` and compile-time inference"):
+ *
+ *   1. **`defineConfig`** — uses `const`-generics on plugins / observers
+ *      to infer the union of observer names, then constrains
+ *      {@link Rule.observer} string references to that union. Typos in
+ *      `observer: "description-read"` (when the plugin registers
+ *      `description-reads`) produce a compile error.
+ *
+ *   2. **`satisfies SteeringConfig`** — plain TypeScript construct users
+ *      can fall back to when they don't want the generic inference
+ *      complexity. Gets shape validation but no cross-reference name
+ *      checking.
+ *
+ * The function itself does minimal runtime work — it just returns the
+ * config unchanged. All the value is in the types.
+ *
+ * Generics threaded through (ADR §8):
+ *   - `AllObserverNames<P, Inline>` — for `Rule.observer` string refs.
+ *   - `AllWrites<P, R, Inline>`     — for `Rule.when.happened.event`.
+ *   - `AllRuleNames<P, R>`          — for `config.disabledRules`.
+ *   - `AllPluginNames<P>`           — for `config.disabledPlugins`.
+ *
+ * All four helpers are exported from this module but NOT re-exported
+ * from the package root; they're internal plumbing, not user-facing
+ * API. Stable enough that plugin authors who import them directly can
+ * rely on their shape within a single minor version, but the contract
+ * is "use via defineConfig".
+ */
+import type { DEFAULT_PLUGINS, DEFAULT_RULES } from "./defaults.ts";
+import type { Observer, Plugin, Rule, SteeringConfig } from "./schema.ts";
+/**
+ * Pull a single projection off every element of an array type.
+ *
+ *   - `K = "name"`   — value is the element's `name` literal
+ *                       (`{ name: N }` → `N`).
+ *   - `K = "writes"` — value is each element of the element's
+ *                       `writes` tuple (`{ writes: readonly [..., S] }`
+ *                       → `S`).
+ *
+ * Elements missing the field (optional `writes`, widened `name`)
+ * contribute `never`. Non-tuple `T` inputs short-circuit to `never`.
+ */
+type ProjectField<T, K extends "name" | "writes"> = T extends readonly (infer E)[] ? E extends Record<K, infer V> ? K extends "writes" ? V extends readonly (infer S extends string)[] ? S : never : V extends string ? V : never : never : never;
+/**
+ * Walk a tuple of plugins and union a {@link ProjectField} projection
+ * across every plugin's `Source` array (`"rules"` or `"observers"`).
+ *
+ * Replaces four near-identical recursive walkers that differed only in
+ * `(Source, K)` pair — see git blame for the pre-R2 shape.
+ */
+type FromPluginField<P extends readonly Plugin[], Source extends "rules" | "observers", K extends "name" | "writes"> = P extends readonly [infer First, ...infer Rest] ? (First extends Plugin ? First[Source] extends infer X ? X extends readonly (Rule | Observer)[] ? ProjectField<X, K> : never : never : never) | (Rest extends readonly Plugin[] ? FromPluginField<Rest, Source, K> : never) : never;
+/**
+ * Extract the union of observer names registered across:
+ *   - every plugin's `observers: Observer[]` array, AND
+ *   - the top-level inline `observers: Observer[]` array.
+ *
+ * Used to constrain string references in {@link Rule.observer} so typos
+ * surface as compile errors in `defineConfig` call sites.
+ *
+ * Falls back to `never` when no observers are registered (correct:
+ * string references should be rejected entirely when there's nothing
+ * to reference).
+ */
+export type AllObserverNames<P extends readonly Plugin[], Inline extends readonly Observer[]> = FromPluginField<P, "observers", "name"> | ProjectField<Inline, "name">;
+/**
+ * Union of {@link DEFAULT_RULES} `name` literals — the names of rules
+ * shipped by the engine itself. Folded into {@link AllRuleNames}; the
+ * live list is the `name` field of each entry in {@link DEFAULT_RULES}.
+ *
+ * Relies on {@link DEFAULT_RULES} being authored as
+ * `as const satisfies readonly Rule[]` so the literal `name` values
+ * survive through the array — a bare `Rule[]` annotation widens to
+ * `string` and collapses this union.
+ */
+export type DefaultRuleName = (typeof DEFAULT_RULES)[number]["name"];
+/**
+ * Union of {@link DEFAULT_PLUGINS} `name` literals. Folded into
+ * {@link AllPluginNames} so `disabledPlugins` typechecks against
+ * shipped defaults without a cast.
+ */
+export type DefaultPluginName = (typeof DEFAULT_PLUGINS)[number]["name"];
+/**
+ * Extract the union of plugin names registered in the `plugins` tuple,
+ * **plus** the names of {@link DEFAULT_PLUGINS} (those plugins ship
+ * pre-loaded by the engine and `disabledPlugins` honors them at
+ * runtime).
+ *
+ * Used to constrain {@link SteeringConfig.disabledPlugins} so typos
+ * surface as compile errors. Default-plugin names are always part of
+ * this union, even when the user passes no `plugins` themselves.
+ *
+ * Falls back to just {@link DefaultPluginName} when no user plugins
+ * are registered — typing `disabledPlugins` against an empty
+ * user-tuple still accepts the engine defaults.
+ */
+export type AllPluginNames<P extends readonly Plugin[]> = DefaultPluginName | ProjectField<P, "name">;
+/**
+ * Extract the union of rule names across:
+ *   - every {@link DEFAULT_RULES} entry (engine-shipped defaults),
+ *   - every plugin's `rules: Rule[]` array, AND
+ *   - the top-level inline `rules: Rule[]` array.
+ *
+ * Used to constrain {@link SteeringConfig.disabledRules} so typos
+ * surface as compile errors. Default rule names are always part of
+ * this union — disabling a default (`disabledRules: ["no-force-push"]`)
+ * typechecks the same as disabling a user or plugin rule.
+ *
+ * Falls back to just {@link DefaultRuleName} when no plugin or user
+ * rules are registered.
+ */
+export type AllRuleNames<P extends readonly Plugin[], R extends readonly Rule[]> = DefaultRuleName | FromPluginField<P, "rules", "name"> | ProjectField<R, "name">;
+/**
+ * Extract the union of session-entry custom types declared via `writes`
+ * arrays across:
+ *   - every plugin's `rules: Rule[]` (rule-side writes via `onFire`),
+ *   - every plugin's `observers: Observer[]` (observer-side writes),
+ *   - the top-level inline `rules`, AND
+ *   - the top-level inline `observers`.
+ *
+ * Used to constrain {@link BuiltInWhenLeavesOuter.happened} `event` so typos
+ * (e.g., `happened: { event: "sync-don" }` when the observer writes
+ * `"sync-done"`) surface as compile errors.
+ *
+ * Authors who omit `writes` on a rule/observer don't contribute to the
+ * union — the rule's write is undeclared, and any downstream
+ * `when.happened.event` referencing it will be rejected. Matches the
+ * "declare your writes" discipline that `writes[]` encourages.
+ */
+export type AllWrites<P extends readonly Plugin[], R extends readonly Rule[], Inline extends readonly Observer[] = readonly []> = FromPluginField<P, "rules", "writes"> | FromPluginField<P, "observers", "writes"> | ProjectField<R, "writes"> | ProjectField<Inline, "writes">;
+/**
+ * Config author surface — the shape `defineConfig` accepts. Matches
+ * {@link SteeringConfig} but with `const`-generic tuple slots on
+ * `plugins` / `rules` / `observers` so tuple literal types survive
+ * through the call and drive name inference.
+ *
+ * Generic constraints:
+ *   - `disabledRules` / `disabledPlugins` typed against the rule / plugin
+ *     name unions — typos rejected at compile time.
+ *   - `rules[].when.happened.event` and `rules[].when.happened.since`
+ *     are both typed against `AllWrites` — typos rejected at compile
+ *     time.
+ */
+export interface DefineConfigInput<P extends readonly Plugin[], Inline extends readonly Observer[], R extends readonly Rule<AllObserverNames<P, Inline>, AllWrites<P, R, Inline>>[]> extends SteeringConfig {
+    disabledRules?: readonly AllRuleNames<P, R>[];
+    disabledPlugins?: readonly AllPluginNames<P>[];
+    plugins?: P;
+    rules?: R;
+    observers?: Inline;
+}
+/**
+ * Build a {@link SteeringConfig} with cross-reference name checking.
+ *
+ * Observer references in {@link Rule.observer} are typed against the
+ * union of observer names gathered from `plugins[*].observers` AND the
+ * top-level `observers` array — a typo produces a compile error.
+ *
+ * The `disabledRules` / `disabledPlugins` arrays are typed against the unions
+ * of registered rule / plugin names — typos rejected.
+ *
+ * `rules[].when.happened.event` and `rules[].when.happened.since` are
+ * both typed against the union of all `writes` declarations across
+ * plugin rules, plugin observers, user rules, and user observers —
+ * typos rejected. (The `since` field on the `Writes` union enforces
+ * the same contract as `event`: the sentinel event must be known to
+ * the config, not a free-form string.)
+ *
+ * Runtime behavior: returns a shallow copy of the input with optional
+ * fields normalized from `readonly` arrays to mutable arrays (the
+ * {@link SteeringConfig} shape doesn't constrain mutability). The
+ * return value is safe to pass to the loader / buildConfig.
+ *
+ * ## Authoring pattern — preserving observer/plugin names for inference
+ *
+ * For compile-time typo detection on rule `observer` references, declare
+ * your observers and plugins with `as const satisfies` so TypeScript
+ * preserves the literal `name` values through to `AllObserverNames`:
+ *
+ *     const myObs = {
+ *       name: "description-read",
+ *       onResult: (event, ctx) => { ... },
+ *     } as const satisfies Observer;
+ *
+ *     const myPlugin = {
+ *       name: "my-plugin",
+ *       observers: [{ name: "sync-done", onResult: ... }],
+ *     } as const satisfies Plugin;
+ *
+ * Authors who prefer type annotations (`const myObs: Observer = ...`)
+ * get widened `name: string`, which collapses `AllObserverNames` to
+ * `string` and silently disables typo detection. Use `as const satisfies`
+ * to keep the inference.
+ *
+ * ## Behavior with no observers declared
+ *
+ * When no plugins contribute observers AND no inline `observers[]` is
+ * passed, `AllObserverNames` resolves to `never`, which causes ANY
+ * string `observer` reference on a Rule to be a compile error. This is
+ * deliberate — fail-closed on unknown observer names. For configs that
+ * deliberately reference observers by name without registering them
+ * inline (e.g., deferred to runtime), use `satisfies SteeringConfig`
+ * as a fallback; you lose typo detection but regain flexibility.
+ *
+ * ## Hover ergonomics for plugin-predicate JSDoc
+ *
+ * The `const R extends readonly Rule[]` signature narrows the
+ * contextual type of inline rule literals to their `const`-inferred
+ * shape, bypassing the homomorphic mapped-type linkage that surfaces
+ * source-declared JSDoc on hover (e.g. on `when.isClean:`). Factor
+ * rules out into `const myRule = { ... } as const satisfies Rule`
+ * bindings before passing them to `defineConfig` to keep the
+ * hover-rich shape; see the
+ * `examples/dynamic-reason-runtime-cwd/steering.ts` example. The
+ * `as const` modifier on the binding (and the `const R` modifier on
+ * the signature) preserves each rule's literal `name` so
+ * `disabledRules` typo detection fires — the alternatives `: Rule`
+ * and bare `satisfies Rule` restore hover but widen the inferred
+ * type and collapse typo detection (and `when.happened.event`
+ * narrowing across declared `writes`).
+ *
+ * @example
+ *   export default defineConfig({
+ *     plugins: [gitPlugin],
+ *     observers: [descriptionReadObserver],
+ *     rules: [
+ *       { name: "must-read-docs", ..., observer: "description-read" },
+ *     ],
+ *   });
+ */
+export declare function defineConfig<const P extends readonly Plugin[] = [], const Inline extends readonly Observer[] = [], const R extends readonly Rule<AllObserverNames<P, Inline>, AllWrites<P, R, Inline>>[] = []>(config: DefineConfigInput<P, Inline, R>): SteeringConfig;
+export {};
+//# sourceMappingURL=define-config.d.ts.map

package/dist/define-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-config.d.ts","sourceRoot":"","sources":["../src/define-config.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAEV,QAAQ,EACR,MAAM,EACN,IAAI,EACJ,cAAc,EACf,MAAM,aAAa,CAAC;AAOrB;;;;;;;;;;;GAWG;AACH,KAAK,YAAY,CACf,CAAC,EACD,CAAC,SAAS,MAAM,GAAG,QAAQ,IACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAC9B,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAC1B,CAAC,SAAS,QAAQ,GAChB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,SAAS,MAAM,CAAC,EAAE,GAC3C,CAAC,GACD,KAAK,GACP,CAAC,SAAS,MAAM,GACd,CAAC,GACD,KAAK,GACT,KAAK,GACP,KAAK,CAAC;AAEV;;;;;;GAMG;AACH,KAAK,eAAe,CAClB,CAAC,SAAS,SAAS,MAAM,EAAE,EAC3B,MAAM,SAAS,OAAO,GAAG,WAAW,EACpC,CAAC,SAAS,MAAM,GAAG,QAAQ,IACzB,CAAC,SAAS,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAE3C,CAAC,KAAK,SAAS,MAAM,GACjB,KAAK,CAAC,MAAM,CAAC,SAAS,MAAM,CAAC,GAC3B,CAAC,SAAS,SAAS,CAAC,IAAI,GAAG,QAAQ,CAAC,EAAE,GACpC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAClB,KAAK,GACP,KAAK,GACP,KAAK,CAAC,GACV,CAAC,IAAI,SAAS,SAAS,MAAM,EAAE,GAC3B,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,GAChC,KAAK,CAAC,GACd,KAAK,CAAC;AAEV;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,SAAS,MAAM,EAAE,EAC3B,MAAM,SAAS,SAAS,QAAQ,EAAE,IAChC,eAAe,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAM3E;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAErE;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAMzE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,IAClD,iBAAiB,GACjB,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAM5B;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,SAAS,SAAS,MAAM,EAAE,EAC3B,CAAC,SAAS,SAAS,IAAI,EAAE,IAEvB,eAAe,GACf,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GACnC,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAM5B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CACnB,CAAC,SAAS,SAAS,MAAM,EAAE,EAC3B,CAAC,SAAS,SAAS,IAAI,EAAE,EACzB,MAAM,SAAS,SAAS,QAAQ,EAAE,GAAG,SAAS,EAAE,IAE9C,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,GACrC,eAAe,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,CAAC,GACzC,YAAY,CAAC,CAAC,EAAE,QAAQ,CAAC,GACzB,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAMnC;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,iBAAiB,CAChC,CAAC,SAAS,SAAS,MAAM,EAAE,EAC3B,MAAM,SAAS,SAAS,QAAQ,EAAE,EAClC,CAAC,SAAS,SAAS,IAAI,CACrB,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC,EAC3B,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CACxB,EAAE,CACH,SAAQ,cAAc;IACtB,aAAa,CAAC,EAAE,SAAS,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;IAC9C,eAAe,CAAC,EAAE,SAAS,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/C,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ,KAAK,CAAC,EAAE,CAAC,CAAC;IACV,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,wBAAgB,YAAY,CAC1B,KAAK,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,GAAG,EAAE,EACtC,KAAK,CAAC,MAAM,SAAS,SAAS,QAAQ,EAAE,GAAG,EAAE,EAC7C,KAAK,CAAC,CAAC,SAAS,SAAS,IAAI,CAC3B,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC,EAC3B,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CACxB,EAAE,GAAG,EAAE,EACR,MAAM,EAAE,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,GAAG,cAAc,CAmCzD"}