looply-cli 0.0.0-stage → 0.2.0

package/dist/provider-state.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerExecutableFor = providerExecutableFor;
+exports.providerProfileDir = providerProfileDir;
+exports.checkProviderAuth = checkProviderAuth;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+/**
+ * WHO OWNS THE PROVIDER'S CREDENTIAL. NOT LOOPLY.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THIS FILE USED TO COPY THE OPERATOR'S SUBSCRIPTION CREDENTIAL INTO EVERY
+ * RUN. `seedProviderState` read `~/.claude/.credentials.json` and wrote it into
+ * each run's sterile session directory, once per launch. It worked, and it was
+ * never approved as a design: Looply held a copy of a credential it does not
+ * own, in a directory it also sweeps as residue, once per execution. Nine such
+ * copies were found on this machine and disposed of.
+ *
+ * The provider owns its own credential now. Looply stores a PATH.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * HOW IT WORKS, AND WHY THIS PARTICULAR MECHANISM.
+ *
+ * `CLAUDE_CONFIG_DIR` relocates the provider's whole profile — where it looks
+ * for credentials and where it keeps project state. Verified against the
+ * installed 2.1.260 rather than assumed: pointed at an empty directory, `auth
+ * status` reported `loggedIn: false` and a `projectsDirectory` inside it. Both
+ * halves matter. It relocates, AND it starts clean rather than inheriting the
+ * operator's `~/.claude` login, settings, hooks, plugins or transcripts.
+ *
+ * ⚠️ THE PROFILE IS MACHINE STATE, NOT PROJECT STATE. It is resolved from the
+ * daemon's own home, never from `.looply/config.yaml` — that file is inside the
+ * worktree, which the model may edit. A worker that could name the provider
+ * profile could point it at a directory it had written.
+ *
+ * ⚠️ AND IT IS DELIBERATELY NOT UNDER `provider-sessions/`. That tree is
+ * residue: `workspace-residue-sweep` deletes it when a workspace is retired. A
+ * credential store inside a cleanup root is a credential store a reap destroys.
+ *
+ * ⚠️ WHAT THIS DOES NOT CLAIM. Not process confinement — the provider still runs
+ * with host-user authority and can read what the operator can read. Not separate
+ * account quotas, not logout independence on the account side, and not secure
+ * erasure of anything. It is narrower than all of those: Looply no longer copies
+ * or handles the credential, and the provider manages its own.
+ */
+/**
+ * The persistent, operator-controlled provider profile.
+ *
+ * One per machine, beside Looply's other machine state. The operator logs into
+ * it once with the provider's own flow; nothing here reads what lands there.
+ */
+/**
+ * The provider executable inside an installed Claude Code package.
+ *
+ * 🔴 ONE DEFINITION, BECAUSE TWO WOULD DRIFT. `model-transport` composes this
+ * path to launch the provider and `doctor` needs the identical one to ask whether
+ * that provider is logged in. A readiness check against a different binary is the
+ * same class of mistake as one against a different profile: it answers honestly
+ * about something nobody is going to run.
+ *
+ * `null` in, `null` out — no package, no executable, and the caller says so in
+ * its own words.
+ */
+function providerExecutableFor(packageDir) {
+    return packageDir === null ? null : (0, node_path_1.join)(packageDir, 'bin', 'claude.exe');
+}
+function providerProfileDir(deps = {}) {
+    return (0, node_path_1.join)(deps.home ?? (0, node_os_1.homedir)(), '.looply', 'provider-profile');
+}
+const DEFAULT_STATUS_TIMEOUT_MS = 20_000;
+function defaultRun(exe, argv, env, timeoutMs) {
+    return (0, node_child_process_1.execFileSync)(exe, [...argv], {
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        env: env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+}
+/**
+ * Is the provider ready to authenticate itself, in the profile the run will use?
+ *
+ * ⚠️ NO MODEL IS INVOKED. `auth status` is a local command that prints the
+ * profile's own state as JSON. Checking whether a login exists must not cost a
+ * turn, and a check that did would be a check nobody could afford to run.
+ *
+ * ⚠️ AND IT ASKS IN THE SAME PROFILE THE RUN WILL USE. A readiness check against
+ * a different `CLAUDE_CONFIG_DIR` answers a different question, which is exactly
+ * the class of mistake `doctor --provider` was repaired for once already.
+ *
+ * Nothing here reads, parses, copies or transports a credential. The only thing
+ * consumed is a boolean and a method name.
+ */
+function checkProviderAuth(executable, env, deps = {}) {
+    const profile = providerProfileDir(deps);
+    // Created rather than required: an empty profile is a profile the operator
+    // can log into, and refusing before it exists helps nobody.
+    try {
+        (0, node_fs_1.mkdirSync)(profile, { recursive: true });
+    }
+    catch {
+        /* a profile that cannot be made shows up as a status failure below */
+    }
+    if (!(0, node_fs_1.existsSync)(executable)) {
+        return {
+            ok: false,
+            reason: 'no_executable',
+            profile,
+            because: `no provider executable at ${executable}`,
+        };
+    }
+    const run = deps.run ?? defaultRun;
+    let out;
+    try {
+        out = run(executable, ['auth', 'status'], env, deps.timeoutMs ?? DEFAULT_STATUS_TIMEOUT_MS);
+    }
+    catch (e) {
+        const err = e;
+        // `execFileSync` reports a timeout by killing the child, which surfaces as a
+        // signal rather than as a distinct code.
+        if (err.code === 'ETIMEDOUT' || err.signal === 'SIGTERM') {
+            return {
+                ok: false,
+                reason: 'timed_out',
+                profile,
+                because: `the provider did not answer \`auth status\` within the timeout`,
+            };
+        }
+        /**
+         * 🔴 A NON-ZERO EXIT IS HOW THIS PROVIDER SAYS "NOT LOGGED IN".
+         *
+         * Measured on 2.1.260 against an empty profile: exit status 1, empty
+         * stderr, and the correct JSON on stdout saying `loggedIn: false`. The
+         * first version of this function read the exit code and reported
+         * `status_failed` — which is the same error in the other direction as
+         * calling everything a login problem. An answer that ARRIVED must be read
+         * before the exit code is judged.
+         */
+        const said = String(err.stdout ?? '');
+        if (said.trim() !== '') {
+            out = said;
+        }
+        else {
+            return {
+                ok: false,
+                reason: 'status_failed',
+                profile,
+                because: `\`auth status\` failed with no answer: ${err.message}`,
+            };
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(out);
+    }
+    catch {
+        return {
+            ok: false,
+            reason: 'unreadable_status',
+            profile,
+            // The ANSWER's shape, never its content: a status blob could carry an
+            // account identifier, and this line goes into logs.
+            because: `\`auth status\` did not answer JSON (${out.length} bytes)`,
+        };
+    }
+    if (parsed.loggedIn !== true) {
+        return {
+            ok: false,
+            reason: 'unauthenticated',
+            profile,
+            because: `the provider is not logged in for this profile. Run: ` +
+                `CLAUDE_CONFIG_DIR=${profile} "${executable}" auth login`,
+        };
+    }
+    return {
+        ok: true,
+        profile,
+        method: typeof parsed.authMethod === 'string' ? parsed.authMethod : 'unknown',
+    };
+}
+//# sourceMappingURL=provider-state.js.map

package/dist/provider-state.js.map

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

package/dist/providers.d.ts

@@ -0,0 +1,132 @@
+import type { AgentSpec } from './agent-exec';
+/**
+ * THE PROVIDERS LOOPLY KNOWS HOW TO START, AND HOW WELL IT KNOWS THEM.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 EVERY PRESET CARRIES ITS PROVENANCE, AND THAT IS THE POINT OF THIS FILE.
+ *
+ * A preset is a command line: a binary, some flags, and an assumption about how
+ * the prompt reaches the model. Getting any of it wrong produces a process that
+ * starts, accepts a prompt, and does nothing useful — or worse, one that hangs
+ * for the whole of an overnight run.
+ *
+ * So each preset says whether it has been EXERCISED or merely DECLARED:
+ *
+ *   'exercised'  a real process has been driven through this exact command line
+ *                in a test in this repository, and the transcript came back.
+ *   'declared'   written from a provider's documentation. Nobody here has run
+ *                it. It is a starting point for a person to confirm, not a
+ *                promise that it works.
+ *
+ * ⚠️ A `declared` PRESET IS NOT A BUG AND MUST NOT BE PRESENTED AS VERIFIED.
+ * Neither the Codex CLI nor the Gemini CLI is installed on the machine this was
+ * built on — `command -v` finds neither — so shipping their flags as known-good
+ * would be inventing a measurement. What closes that gap is not more confident
+ * wording; it is `preflightProvider`, which runs the thing on the machine that
+ * has it and reports what actually happened.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY A REGISTRY AT ALL, GIVEN `agent.command` ALREADY TAKES ANY STRING
+ *
+ * Because the string is the easy half. The hard half is the three facts around
+ * it — whether the prompt goes on stdin or in an argument, whether the binary
+ * has an output-format flag, and where its runtime lives so containment can
+ * grant it — and those are what a person cannot guess and will get wrong.
+ */
+/** How the prompt reaches the model. */
+export type PromptChannel = 
+/**
+ * Written to the process's stdin, which is what Looply does everywhere.
+ *
+ * 🔴 THE ONLY CHANNEL THE TRANSPORT IMPLEMENTS. A provider needing anything
+ * else is not merely differently configured — it needs code, and saying so is
+ * the honest form of this field. See `SUPPORTED_PROMPT_CHANNELS`.
+ */
+'stdin'
+/** Passed as a trailing command-line argument. NOT IMPLEMENTED. */
+ | 'argument';
+/**
+ * What the transport can actually deliver today.
+ *
+ * ⚠️ A PRESET NAMING AN UNSUPPORTED CHANNEL IS REFUSED AT RESOLUTION RATHER
+ * THAN AT ROUND 1. The alternative is a run that starts, writes a prompt into a
+ * stdin nothing is reading, and waits — which looks exactly like a slow model.
+ */
+export declare const SUPPORTED_PROMPT_CHANNELS: readonly PromptChannel[];
+export type Provenance = 'exercised' | 'declared';
+export interface ProviderPreset {
+    /** The name a person writes in `agent.provider`. */
+    readonly id: string;
+    /** What it is, for a message a person reads. */
+    readonly label: string;
+    readonly spec: AgentSpec;
+    readonly promptChannel: PromptChannel;
+    readonly provenance: Provenance;
+    /**
+     * Where the flags came from, in one sentence.
+     *
+     * 🔴 REQUIRED, INCLUDING FOR `exercised` ONES. "It works" is not provenance;
+     * what ran, and what it proved, is.
+     */
+    readonly source: string;
+}
+/**
+ * ⚠️ ORDER IS NOT PREFERENCE. This is a lookup, and presenting it as a ranking
+ * would imply a comparison nobody here has made — two of the three have never
+ * been run at all.
+ */
+export declare const PROVIDER_PRESETS: readonly ProviderPreset[];
+export declare function findPreset(id: string): ProviderPreset | undefined;
+export interface ResolveOk {
+    ok: true;
+    spec: AgentSpec;
+    preset: ProviderPreset | null;
+    /**
+     * Said out loud when a preset has never been run here.
+     *
+     * ⚠️ A WARNING, NOT A REFUSAL. Refusing would make Looply unusable with a
+     * provider that works perfectly well and simply has not been tested in this
+     * repository — which is a statement about us, not about the provider.
+     */
+    warning: string | null;
+}
+export interface ResolveErr {
+    ok: false;
+    message: string;
+}
+/**
+ * Turn a configured provider name into a spec, or say why it cannot be one.
+ *
+ * ⚠️ FLAT RESULT, NOT A DISCRIMINATED UNION ON A NEGATED TAG. `strict` is off in
+ * this repository and `if (!r.ok) return r.message` does not narrow; the shape
+ * here is the one that survives that.
+ */
+export declare function resolveProvider(input: {
+    readonly provider?: string;
+    readonly spec: AgentSpec;
+}): ResolveOk | ResolveErr;
+/**
+ * The agent spec a command should actually launch, preset applied.
+ *
+ * 🔴 THREE COMMANDS RESOLVED THE SAME PROJECT THREE DIFFERENT WAYS. `looply
+ * run` called `resolveProvider`; `looply scan` and `looply verify` passed
+ * `config.agent` straight through, so `agent.provider` was ignored entirely and
+ * the same repository used a different binary depending on which verb was
+ * typed. A preset that supplies "the prompt goes on stdin" and "this binary has
+ * no output-format flag" is not advice — it is how the process is started, and
+ * a command that skips it starts a different process.
+ *
+ * One function, so a fourth command cannot invent a fourth answer.
+ */
+export declare function agentSpecFor(config: {
+    readonly provider?: string;
+    readonly agent: AgentSpec;
+}): {
+    ok: true;
+    spec: AgentSpec;
+    warning: string | null;
+} | {
+    ok: false;
+    message: string;
+};
+//# sourceMappingURL=providers.d.ts.map

package/dist/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../src/providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,wCAAwC;AACxC,MAAM,MAAM,aAAa;AACvB;;;;;;GAMG;AACD,OAAO;AACT,mEAAmE;GACjE,UAAU,CAAC;AAEf;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,aAAa,EAAc,CAAC;AAE7E,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC;AAElD,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EAwCrD,CAAC;AAEF,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEjE;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IAC9B;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B,GAAG,SAAS,GAAG,UAAU,CA2EzB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;CAC3B,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAOzF"}

package/dist/providers.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_PRESETS = exports.SUPPORTED_PROMPT_CHANNELS = void 0;
+exports.findPreset = findPreset;
+exports.resolveProvider = resolveProvider;
+exports.agentSpecFor = agentSpecFor;
+/**
+ * What the transport can actually deliver today.
+ *
+ * ⚠️ A PRESET NAMING AN UNSUPPORTED CHANNEL IS REFUSED AT RESOLUTION RATHER
+ * THAN AT ROUND 1. The alternative is a run that starts, writes a prompt into a
+ * stdin nothing is reading, and waits — which looks exactly like a slow model.
+ */
+exports.SUPPORTED_PROMPT_CHANNELS = ['stdin'];
+/**
+ * ⚠️ ORDER IS NOT PREFERENCE. This is a lookup, and presenting it as a ranking
+ * would imply a comparison nobody here has made — two of the three have never
+ * been run at all.
+ */
+exports.PROVIDER_PRESETS = [
+    {
+        id: 'claude',
+        label: 'Claude Code',
+        spec: {
+            command: 'claude -p --dangerously-skip-permissions',
+            outputFormatFlag: '--output-format',
+        },
+        promptChannel: 'stdin',
+        provenance: 'exercised',
+        source: 'The repository default since the transport was built. Driven end to end by the round e2e suite and by a compiled fake standing in for the real binary, both through this exact command line.',
+    },
+    {
+        id: 'codex',
+        label: 'OpenAI Codex CLI',
+        spec: {
+            // No output-format flag is claimed. An empty string is the contract's own
+            // way of saying "this binary has none", and inventing one would produce a
+            // process refused at startup for an unknown option.
+            command: 'codex exec',
+            outputFormatFlag: '',
+        },
+        promptChannel: 'stdin',
+        provenance: 'declared',
+        source: 'Written from the published CLI documentation. NOT installed on the machine this was built on and never executed here — confirm with `looply doctor --provider` before trusting it.',
+    },
+    {
+        id: 'gemini',
+        label: 'Gemini CLI',
+        spec: {
+            command: 'gemini',
+            outputFormatFlag: '',
+        },
+        promptChannel: 'stdin',
+        provenance: 'declared',
+        source: 'Written from the published CLI documentation. NOT installed on the machine this was built on and never executed here — confirm with `looply doctor --provider` before trusting it.',
+    },
+];
+function findPreset(id) {
+    return exports.PROVIDER_PRESETS.find((p) => p.id === id);
+}
+/**
+ * Turn a configured provider name into a spec, or say why it cannot be one.
+ *
+ * ⚠️ FLAT RESULT, NOT A DISCRIMINATED UNION ON A NEGATED TAG. `strict` is off in
+ * this repository and `if (!r.ok) return r.message` does not narrow; the shape
+ * here is the one that survives that.
+ */
+function resolveProvider(input) {
+    if (input.provider === undefined || input.provider === '') {
+        return { ok: true, spec: input.spec, preset: null, warning: null };
+    }
+    const preset = findPreset(input.provider);
+    if (!preset) {
+        return {
+            ok: false,
+            message: `no such provider: ${input.provider}. Known: ${exports.PROVIDER_PRESETS.map((p) => p.id).join(', ')}. Any other agent is configured with agent.command instead.`,
+        };
+    }
+    if (!exports.SUPPORTED_PROMPT_CHANNELS.includes(preset.promptChannel)) {
+        // 🔴 REFUSED AT RESOLUTION, NOT AT ROUND 1. A provider that wants the
+        // prompt as an argument would otherwise start, be handed a prompt on a
+        // stdin it never reads, and wait — indistinguishable from a slow model.
+        return {
+            ok: false,
+            message: `provider ${preset.id} needs the prompt on its ${preset.promptChannel}, and this build only delivers it on stdin. That is a code change, not a configuration one.`,
+        };
+    }
+    /**
+     * Did the config FILE contain this key?
+     *
+     * A spec with no `declared` list at all — every hand-built one in the tree,
+     * and every fixture — answers false, so a preset supplies its own facts.
+     * That is the direction that cannot silently discard a person's intent,
+     * because a hand-built spec has no person behind it.
+     */
+    const wrote = (key) => (input.spec.declared ?? []).includes(key);
+    return {
+        ok: true,
+        // 🔴 THE PRESET IS A DEFAULT, NOT AN OVERRIDE. An explicit `agent.command`
+        // wins, because somebody who wrote one is telling us something we do not
+        // know — a different binary name, a flag their build needs — and silently
+        // discarding it would be the worst kind of helpful.
+        /**
+         * 🔴 EXPLICIT MEANS WRITTEN DOWN, NOT MERELY PRESENT — AND THE OLD TEST
+         * MADE THE PRESET UNREACHABLE.
+         *
+         * `input.spec.command ? …` looks like "did the person write a command", and
+         * is not: `parseConfig` DEFAULTS `agent.command` to Claude's line, so it is
+         * truthy for every project that ever existed. The preset's command was
+         * therefore overridden every single time, and somebody who wrote
+         * `provider: codex` ran Claude — while being shown a warning about codex
+         * that reads as confirmation that codex is what they got.
+         *
+         * `declared` is the list of keys the FILE contained, so this asks the
+         * question it always meant to ask.
+         *
+         * 🔴 AND `no_host_tools` IS CARRIED. It was not in this spread at all, so a
+         * person who set `provider:` AND declared how their binary's tools are
+         * turned off had the declaration dropped on the floor — and was then
+         * refused at the first model call by a message naming the very field they
+         * had set. It is the one field on this object that decides whether the
+         * launch happens, and it was the one field that could not survive.
+         */
+        spec: {
+            ...preset.spec,
+            ...(wrote('command') ? { command: input.spec.command } : {}),
+            ...(wrote('output_format_flag') ? { outputFormatFlag: input.spec.outputFormatFlag } : {}),
+            ...(input.spec.runtime?.length ? { runtime: input.spec.runtime } : {}),
+            ...(input.spec.env?.length ? { env: input.spec.env } : {}),
+            ...(input.spec.noHostTools?.length ? { noHostTools: input.spec.noHostTools } : {}),
+            ...(input.spec.declared === undefined ? {} : { declared: input.spec.declared }),
+        },
+        preset,
+        warning: preset.provenance === 'declared'
+            ? `provider ${preset.id} has never been run by Looply's own tests: ${preset.source}`
+            : null,
+    };
+}
+/**
+ * The agent spec a command should actually launch, preset applied.
+ *
+ * 🔴 THREE COMMANDS RESOLVED THE SAME PROJECT THREE DIFFERENT WAYS. `looply
+ * run` called `resolveProvider`; `looply scan` and `looply verify` passed
+ * `config.agent` straight through, so `agent.provider` was ignored entirely and
+ * the same repository used a different binary depending on which verb was
+ * typed. A preset that supplies "the prompt goes on stdin" and "this binary has
+ * no output-format flag" is not advice — it is how the process is started, and
+ * a command that skips it starts a different process.
+ *
+ * One function, so a fourth command cannot invent a fourth answer.
+ */
+function agentSpecFor(config) {
+    const resolved = resolveProvider({
+        ...(config.provider === undefined ? {} : { provider: config.provider }),
+        spec: config.agent,
+    });
+    if (!('spec' in resolved))
+        return { ok: false, message: resolved.message };
+    return { ok: true, spec: resolved.spec, warning: resolved.warning };
+}
+//# sourceMappingURL=providers.js.map

package/dist/providers.js.map

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

package/dist/publication-recorder.d.ts

@@ -0,0 +1,117 @@
+import { type PublicationRuling } from '@looply/core';
+import { type CompatibleRecord } from './compatible-sets';
+/**
+ * A PUBLICATION RECORDED FROM AN OPERATION THAT HAPPENED, NOT FROM A PERSON
+ * TYPING ONE.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 `OWNER_CHARTER.md` §6.D, in its own words: *"The programme controller must
+ * drive the existing compatible-set workflow through real local integration
+ * operations, not require me to type 'published' records. Only observed
+ * authorized operations create receipts."*
+ *
+ * So this is called AFTER a real integration tick has already moved a ref —
+ * never before, and never on an intention. A receipt written for work that
+ * might not happen is worse than no receipt, because a person reading it would
+ * believe the convergence had moved.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * ⚠️ IT DECIDES NOTHING ITSELF. Every refusal comes from `publicationRuling` in
+ * core, which is the same function `looply repos --published` calls. That is
+ * the point of the fold existing: a run that wrote its own lines would be a
+ * second implementation of those refusals, and the one that forgets the drift
+ * check is the one that writes down a compatible pair that does not exist.
+ *
+ * ⚠️ AND IT IS NOT ATOMIC ACROSS REPOSITORIES, which the charter also says:
+ * *"No atomic cross-repository transaction claim."* One repository's
+ * publication is one record. The set says what is left.
+ */
+/**
+ * What an integration tick actually did, as the tick reported it.
+ *
+ * ⚠️ NO REPOSITORY ID. The lane moves a ref in the checkout it was given; WHICH
+ * declared repository that checkout is is a question about the config, and
+ * `selfRepoId` answers it where the config is loaded. A lane that had to be
+ * told its own name could be told the wrong one.
+ */
+export interface ObservedRefMove {
+    /** The ref that moved — `looply/integration` today. */
+    readonly ref: string;
+    /** Where that ref points now, as the operation left it. */
+    readonly to: string;
+}
+/** The same move, once somebody has said which declared repository it happened in. */
+export interface ObservedPublication extends ObservedRefMove {
+    readonly repo: string;
+}
+export interface PublicationRecorderDeps {
+    /** Every repository this project declares, with a path that can be read. */
+    declared(): readonly {
+        id: string;
+        path: string;
+    }[];
+    /**
+     * Where a repository is now.
+     *
+     * ⚠️ NULL, NEVER A GUESS — the same contract `ReposDeps` states. An
+     * unreadable repository must reach the ruling as absent so it answers
+     * `unmeasurable`; inventing a sha would turn "I could not look" into "it has
+     * drifted", and those call for opposite things.
+     */
+    revisionOf(repo: {
+        id: string;
+        path: string;
+    }): Promise<{
+        sha: string;
+        from: string;
+    } | null>;
+    records(): Promise<readonly CompatibleRecord[]>;
+    append(record: CompatibleRecord): Promise<void>;
+    now(): string;
+}
+export interface RecorderOutcome {
+    readonly ruling: PublicationRuling;
+    /** True only when a record was appended. Never inferred from the kind. */
+    readonly recorded: boolean;
+    /** One line for the daemon log. */
+    readonly line: string;
+}
+/**
+ * Offer one observed publication to the ruling, and write the record only if it
+ * says to.
+ *
+ * The order matters and is the ruling's, not this function's: what makes the
+ * recording the WRONG ACT first, then drift, then whether it is already down.
+ * The one check that lives here is the last one, because it is about the
+ * OBSERVATION rather than about the set.
+ */
+export declare function recordObservedPublication(deps: PublicationRecorderDeps, observed: ObservedPublication): Promise<RecorderOutcome>;
+/**
+ * Where a repository is now, on this machine.
+ *
+ * ⚠️ ONE IMPLEMENTATION, TWO CALLERS — `looply repos` and the daemon's
+ * integrator. Two copies of "where is this repository" are two copies that can
+ * disagree, and the one that disagrees is the one deciding whether a set has
+ * drifted.
+ */
+export declare function nodeRevisionOf(repo: {
+    id: string;
+    path: string;
+}): Promise<{
+    sha: string;
+    from: string;
+} | null>;
+/**
+ * The daemon's recorder, or nothing at all.
+ *
+ * ⚠️ NOTHING is the right answer for most projects. A project that declares
+ * no sibling repositories has no compatible set to publish against, and a
+ * checkout that is not one of the declared repositories cannot say which one
+ * published — in both cases the honest thing is to have no recorder rather
+ * than one that refuses every tick into the log.
+ */
+export declare function nodePublicationRecorder(cwd: string, projectState: string, declared: readonly {
+    id: string;
+    path: string;
+}[]): ((observed: ObservedRefMove) => Promise<string | null>) | undefined;
+//# sourceMappingURL=publication-recorder.d.ts.map

package/dist/publication-recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publication-recorder.d.ts","sourceRoot":"","sources":["../src/publication-recorder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgD,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACpG,OAAO,EAAyD,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAMjH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,uDAAuD;IACvD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,sFAAsF;AACtF,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,4EAA4E;IAC5E,QAAQ,IAAI,SAAS;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACpD;;;;;;;OAOG;IACH,UAAU,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IAC9F,OAAO,IAAI,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC,CAAC;IAChD,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,GAAG,IAAI,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,uBAAuB,EAC7B,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,eAAe,CAAC,CAkD1B;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAetH;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GAChD,CAAC,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,GAAG,SAAS,CAsBrE"}