@lannguyensi/harness 0.64.0 → 1.0.0

package/dist/runtime/environment-resolver.d.ts

@@ -1,36 +0,0 @@
-import type { EnvironmentResolver, MatchableEnvironment } from "../schema/index.js";
-import type { ActionEnvelope } from "./action-envelope.js";
-export type EnvironmentConfidence = "high" | "medium" | "low";
-export interface EnvironmentResolution {
-    /** Resolved environment, or `unknown` when no resolver matched. */
-    name: MatchableEnvironment;
-    /**
-     * `high` when two or more signals (unioned across every resolver
-     * asserting the winning environment) back the result, `medium` for a
-     * single signal, `low` for `unknown` (no signal matched at all).
-     */
-    confidence: EnvironmentConfidence;
-    /** Matched signal descriptors that back the result, for explainability. */
-    signals: string[];
-    /** Name of the resolver whose environment won, or `null` when unresolved. */
-    resolver: string | null;
-}
-/** Ambient inputs the resolver matches signals against. */
-export interface SignalInputs {
-    /** Environment variables, for `env_var_patterns`. */
-    env: Record<string, string | undefined>;
-    /** Current kube context name, for `kube_context_patterns`. "" when unknown. */
-    kubeContext: string;
-    /** Current kube namespace, for `kube_namespace_patterns`. "" when unknown. */
-    kubeNamespace: string;
-}
-/**
- * Resolve the target environment of an Action Envelope.
- *
- * Pure: envelope + resolvers + ambient inputs in, resolution out, no
- * I/O. When resolvers disagree, the most-dangerous environment wins
- * (`ENV_PRECEDENCE`). Signals from every fired resolver that asserts the
- * winning environment are unioned for explainability. When nothing
- * matches, the result is `unknown` — deliberately not a safe default.
- */
-export declare function resolveEnvironment(envelope: ActionEnvelope, resolvers: readonly EnvironmentResolver[], inputs: SignalInputs): EnvironmentResolution;

package/dist/runtime/environment-resolver.js

@@ -1,138 +0,0 @@
-// Phase 7 #4 — Context Resolver.
-//
-// Classifies an Action Envelope's target environment by matching the
-// manifest's `environments.resolvers[]` signals. The Risk Gate stage
-// that reads the `environments:` schema vocabulary shipped in
-// Phase 7 #1.
-//
-// STATUS: invoked by `harness resolve-env` (Phase 7 #4). NOT yet
-// consumed by `harness policy intercept` — wiring the runtime through
-// the resolver is Phase 7 #5. See docs/risk-gate.md and docs/ROADMAP.md.
-//
-// "Unknown is not safe": when no resolver matches, the environment is
-// `unknown` — not a safe default. The Phase 7 #5 policy evaluator must
-// treat `unknown` as risk-bearing. `MatchableEnvironmentSchema` already
-// admits `unknown` so a `policy.when.environment.name` clause can gate
-// on it.
-//
-// Design source: lava-ice-logs/2026-04-30/harness-risk-gate-extension.md
-// (design phase C).
-// Most-dangerous-wins precedence: when resolvers disagree, the earlier
-// entry here is the resolved environment. `unknown` is the implicit
-// fallback and is not a resolver-assertable value.
-const ENV_PRECEDENCE = [
-    "production",
-    "staging",
-    "dev",
-    "local",
-];
-/**
- * Convert a `*`-glob to an anchored RegExp. Only `*` is special (the
- * Phase 7 #1 signal patterns are simple, e.g. `main`, `release/*`); all
- * other regex metacharacters are escaped literally.
- */
-function globToRegExp(glob) {
-    const escaped = glob
-        .replace(/[.+^${}()|[\]\\?]/g, "\\$&")
-        .replace(/\*/g, ".*");
-    return new RegExp(`^${escaped}$`);
-}
-/**
- * Match one resolver's signals against the envelope + ambient inputs.
- * Signals are OR-ed: a resolver fires when ANY signal matches. Returns
- * the matched signal descriptors (empty when the resolver did not fire).
- *
- * Per-signal-kind semantics: `branch_patterns` and
- * `kube_namespace_patterns` are globs, `kube_context_patterns` are
- * regexes, `env_var_patterns` are substrings of the variable's value.
- */
-function matchResolver(resolver, envelope, inputs) {
-    const matched = [];
-    const sig = resolver.signals;
-    const branch = envelope.session.branch;
-    if (sig.branch_patterns !== undefined && branch !== "") {
-        for (const p of sig.branch_patterns) {
-            if (globToRegExp(p).test(branch)) {
-                matched.push(`branch:${branch} ~ ${p}`);
-            }
-        }
-    }
-    if (sig.env_var_patterns !== undefined) {
-        for (const evp of sig.env_var_patterns) {
-            const value = inputs.env[evp.var];
-            if (typeof value !== "string")
-                continue;
-            for (const p of evp.patterns) {
-                if (value.includes(p)) {
-                    matched.push(`env:${evp.var} contains "${p}"`);
-                }
-            }
-        }
-    }
-    if (sig.kube_context_patterns !== undefined && inputs.kubeContext !== "") {
-        for (const p of sig.kube_context_patterns) {
-            let re;
-            try {
-                re = new RegExp(p);
-            }
-            catch {
-                continue;
-            }
-            if (re.test(inputs.kubeContext)) {
-                matched.push(`kube-context:${inputs.kubeContext} ~ /${p}/`);
-            }
-        }
-    }
-    if (sig.kube_namespace_patterns !== undefined &&
-        inputs.kubeNamespace !== "") {
-        for (const p of sig.kube_namespace_patterns) {
-            if (globToRegExp(p).test(inputs.kubeNamespace)) {
-                matched.push(`kube-namespace:${inputs.kubeNamespace} ~ ${p}`);
-            }
-        }
-    }
-    return matched;
-}
-/**
- * Resolve the target environment of an Action Envelope.
- *
- * Pure: envelope + resolvers + ambient inputs in, resolution out, no
- * I/O. When resolvers disagree, the most-dangerous environment wins
- * (`ENV_PRECEDENCE`). Signals from every fired resolver that asserts the
- * winning environment are unioned for explainability. When nothing
- * matches, the result is `unknown` — deliberately not a safe default.
- */
-export function resolveEnvironment(envelope, resolvers, inputs) {
-    const fired = [];
-    for (const resolver of resolvers) {
-        const signals = matchResolver(resolver, envelope, inputs);
-        if (signals.length > 0)
-            fired.push({ resolver, signals });
-    }
-    if (fired.length === 0) {
-        return { name: "unknown", confidence: "low", signals: [], resolver: null };
-    }
-    let best = fired[0];
-    for (const f of fired) {
-        if (ENV_PRECEDENCE.indexOf(f.resolver.environment) <
-            ENV_PRECEDENCE.indexOf(best.resolver.environment)) {
-            best = f;
-        }
-    }
-    // Union the signals of every fired resolver that asserts the winning
-    // environment, so the explanation is complete when several resolvers
-    // agree. `resolver` names the highest-precedence (first-found) one.
-    const winningEnv = best.resolver.environment;
-    const signals = [
-        ...new Set(fired
-            .filter((f) => f.resolver.environment === winningEnv)
-            .flatMap((f) => f.signals)),
-    ].sort();
-    return {
-        name: winningEnv,
-        confidence: signals.length >= 2 ? "high" : "medium",
-        signals,
-        resolver: best.resolver.name,
-    };
-}
-//# sourceMappingURL=environment-resolver.js.map

package/dist/runtime/environment-resolver.js.map

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

package/dist/runtime/git-context.d.ts

@@ -1,201 +0,0 @@
-export interface GitRepoContext {
-    /** Basename of the work-tree root, or "" when `cwd` is not in a repo. */
-    repo: string;
-    /**
-     * Current branch name, or "" when not in a repo or HEAD is detached
-     * (a raw SHA, there is no branch to name).
-     */
-    branch: string;
-    /**
-     * Current HEAD commit sha (40 lowercase hex chars), or "" when not in
-     * a repo or the sha could not be resolved. On a detached HEAD this is
-     * the raw sha from `.git/HEAD`; on a branch it is the sha pointed at
-     * by `.git/refs/heads/<branch>` (or the matching entry in
-     * `.git/packed-refs` when the loose ref is absent). Used by the
-     * `at_head:true` requires-flag so a preflight whose recorded HEAD
-     * equals the current HEAD satisfies the gate regardless of age.
-     */
-    sha: string;
-}
-export interface GitEntry {
-    /** Directory that contains the `.git` entry (the work-tree root). */
-    worktreeRoot: string;
-    /** Resolved git directory — for a `.git` file, its `gitdir:` target. */
-    gitDir: string;
-}
-/**
- * Walk up from `startDir` looking for a `.git` entry. Handles both the
- * common `.git` directory and the `.git` *file* form used by linked
- * worktrees and submodules. The walk is bounded so a pathologically
- * deep cwd cannot spin.
- *
- * Exported (task T-001, record-verbs) so `cli/record/index.ts` can
- * locate the same `.git` directory this module resolves `repo`/
- * `branch`/`sha` from, without re-walking the tree with duplicate
- * logic — its base-branch resolution needs the raw git directory (to
- * read `refs/remotes/origin/HEAD` / `packed-refs`), which
- * `resolveGitContext`'s return shape does not expose. Behavior is
- * unchanged; this is a visibility-only change.
- */
-export declare function findGitEntry(startDir: string): GitEntry | null;
-/**
- * Resolve `{ repo, branch, sha }` for a working directory. Returns empty
- * strings (never throws) when `cwd` is not inside a git work tree, or
- * when any individual lookup fails: callers treat "" as "unknown" and
- * fall through to their own behaviour.
- */
-export declare function resolveGitContext(cwd: string): GitRepoContext;
-/**
- * Resolve the remote's default branch name from `<gitDir>/refs/remotes/
- * origin/HEAD`. Loose symbolic ref first (the normal shape: `ref: refs/
- * remotes/origin/<name>`, written by `git clone` / `git remote set-head
- * origin -a`). When that loose file is absent, falls back to
- * `packed-refs`: some git versions / tooling pack `refs/remotes/origin/
- * HEAD` as a plain `<sha> <ref>` entry instead of a symref, which loses
- * the branch NAME directly — recovered here by matching that sha
- * against another packed `refs/remotes/origin/<name>` entry that shares
- * it (mirrors the loose-then-packed shape `resolveBranchSha` uses
- * above, adapted since packed-refs has no symref concept). Returns null
- * when neither source resolves a name.
- */
-export declare function resolveOriginHeadBase(gitDir: string): string | null;
-/**
- * Resolve the actual shared git directory for `gitDir`, following the
- * `commondir` file linked worktrees write. `git worktree add` gives each
- * worktree its own private `.git` FILE pointing at `<main>/.git/
- * worktrees/<name>/` (what `findGitEntry` returns as `gitDir`), but
- * `refs/remotes/origin/HEAD` and `packed-refs` are NOT duplicated there
- * — they live only in the shared common dir, reachable via that
- * per-worktree directory's own `commondir` file (a path, normally
- * `../..`, relative to the per-worktree directory itself; see
- * `git-worktree(1)`). Without this indirection, `resolveOriginHeadBase`
- * would look for those refs in the empty per-worktree directory and
- * always miss. Returns `gitDir` unchanged when no `commondir` file
- * exists (the normal, non-worktree case).
- */
-export declare function resolveCommonDir(gitDir: string): string;
-/**
- * Derive the project-layer name for `cwd`: the basename of the
- * directory that CONTAINS the repository's shared git common dir (the
- * main checkout), so every linked worktree of one repository resolves
- * the same name, unlike `resolveGitContext(cwd).repo`, which names the
- * checkout directory itself and therefore differs per worktree. Feeds
- * `LoaderOptions.project` (the same seam every command's own
- * `--project <name>` flag already uses) for `harness session-start
- * preflight`, `harness explain-policy`, and `harness doctor` alike (one
- * helper, three consumers, so the three cannot silently disagree on
- * what "this repository's project name" means).
- *
- * Resolution:
- *  - `findGitEntry(cwd)` walks up to the `.git` entry, exactly like
- *    `resolveGitContext`.
- *  - `resolveCommonDir(entry.gitDir)` follows a linked worktree's
- *    `commondir` file to the shared common dir (a no-op for the main
- *    checkout, which has none).
- *  - The COMMON DIR's basename is normally literally `.git` (a
- *    directory or, in a linked worktree's private gitdir, the resolved
- *    target of a `.git` FILE): in that shape the project name is one
- *    level further up, the basename of the directory THAT CONTAINS the
- *    common dir, i.e. the main checkout's own directory name.
- *  - For a BARE repository (`git init --bare`, or a linked worktree
- *    created FROM one), there is no `.git` wrapper at all, the common
- *    dir IS the bare directory itself (its basename is not `.git`), so
- *    that basename is the project name directly, with no extra `..`
- *    step. This is the one shape where going up an extra level would
- *    be wrong (it would name the bare directory's PARENT instead), and
- *    the `.git` SUFFIX in a conventionally-named bare directory (e.g.
- *    `myrepo.git`) is kept, not stripped.
- *  - A SUBMODULE checkout (`git submodule add`) derives the submodule's
- *    OWN name, not its superproject's: a submodule's `.git` FILE points
- *    at a private gitdir under the superproject's `.git/modules/<name>/`
- *    tree, which has no `commondir` file of its own (that mechanism is
- *    for linked worktrees, not submodules), so `resolveCommonDir` is a
- *    no-op and the submodule's own checkout directory basename applies
- *    directly, same as a normal (non-worktree) repo.
- *  - A `git init --separate-git-dir=<dir>` checkout derives the GIT
- *    DIR's own basename, NOT the work tree's: the `.git` file at the
- *    work tree root points at `<dir>` with no `commondir` file either
- *    (again a linked-worktree-only mechanism), so `resolveCommonDir` is
- *    a no-op and `<dir>`'s own basename (e.g. `sepgit.git`) is the
- *    derived name, exactly like the bare-repository shape above; the
- *    work tree's own directory name never enters into it.
- *
- * Returns `null` when `cwd` is not inside a git work tree (mirrors
- * `resolveGitContext`'s "" for the same case), when `entry.gitDir`
- * could not be resolved at all (an unreadable `.git` FILE, see
- * `findGitEntry`'s doc comment; in that case this falls back to the
- * checkout directory's own basename, the same value `repo` would
- * carry, rather than guessing at a common dir it has no path to), or
- * when the resolved name fails {@link isValidProjectName} (review
- * round 3, decision D-028's security finding: an untrusted on-disk
- * `commondir`/`.git` FILE value must never hand a caller a name like
- * `""`, `"."`, `".."`, or one containing a path separator, since every
- * consumer joins it straight into a filesystem path,
- * `resolvePaths`/`src/cli/loader.ts`; task `e904f25a` extended the same
- * exit to a name containing a control character, which no consumer could
- * render safely). A rejection here is silent by design: no project
- * override layer resolves for that repository and the base/machine value
- * applies, exactly as for a repository that simply has no layer on disk.
- * Never throws.
- *
- * REALPATH (task c88461c1, review round 3 residual; task `1c4eb3ea`
- * of the batch-44 follow-up run): the common dir is resolved through
- * `fs.realpathSync` BEFORE taking its basename, so a checkout reached
- * through a symlink (an operator's own convenience symlink, or a
- * second clone path) derives the SAME project name as the real
- * directory it points at, matching D-021a's "repository identity is
- * the common dir" rule: two paths to one repository must resolve one
- * project layer, not two. Best-effort: `realpathSync` failing (a
- * dangling symlink, a permissions error) falls back to the
- * un-resolved common dir rather than throwing, so a repository that
- * was reachable before this change stays reachable.
- */
-export declare function deriveProjectName(cwd: string): string | null;
-export interface ResolveScopedProjectNameOptions<T> {
-    /** An explicit `--project <name>` value, when the caller has one. Wins outright. */
-    project?: string;
-    /** The cwd to derive a project name from via {@link deriveProjectName}. */
-    cwd: string;
-    /**
-     * What to return when neither `project` nor `deriveProjectName(cwd)`
-     * produced a name. Callers disagreed on this value before this helper
-     * existed: `harness doctor` used `null`, the `session_start_preflight`
-     * producer used its own already-resolved `repo` basename. Naming it
-     * here makes that difference a visible, per-call-site argument instead
-     * of an accident of two copies of the same expression drifting apart
-     * (task `f1eb1c5c`; see docs/CLI.md's PER-REPO SCOPING section).
-     */
-    fallback: T;
-}
-/**
- * Shared `opts.project ?? deriveProjectName(cwd) ?? fallback` resolution,
- * used by two of the three producers of a per-repo-scoped
- * `session_start_preflight` project name: `harness doctor`'s second,
- * project-scoped load and the `session_start_preflight` producer. Both
- * surfaces agree on the first two terms (an explicit `--project`, then
- * the cwd-derived name); only the fallback differs by call site, and
- * this helper takes it as an explicit argument so that difference is
- * named rather than duplicated inline. The third producer,
- * `harness explain-policy` (`src/cli/explain-policy.ts`), keeps its own
- * copy of the same expression with a third fallback (`undefined`);
- * folding it into this helper is deliberately out of scope of task
- * `f1eb1c5c`. No observable behaviour change versus either surface's
- * own prior inline expression, other than doctor's `cwd` expression
- * now being evaluated eagerly (see the call site): this only extracts
- * the shared shape.
- */
-export declare function resolveScopedProjectName<T>(opts: ResolveScopedProjectNameOptions<T>): string | T;
-/**
- * `{project}` value validation and safe display now live in
- * `src/io/project-name.ts` (task `b5e6ccb0`): `buildLockEntries`
- * (`src/io/harness-lock.ts`) is itself a `{project}` sink, and `io/` may
- * not import from `runtime/` (`io-no-upward-imports`,
- * `.dependency-cruiser.cjs`), so the shared logic moved down rather than
- * `harness-lock.ts` re-implementing it. Re-exported here so every
- * existing consumer that imports `isValidProjectName` /
- * `sanitizeProjectForDisplay` from `../runtime/git-context.js` keeps
- * working unchanged; see `src/io/project-name.ts` for the doc comments
- * (the sink inventory, the two-screen rationale, the display-stripping
- * invariant).
- */
-export { isValidProjectName, sanitizeProjectForDisplay } from "../io/project-name.js";