agenticreplay 0.1.0 → 0.1.2

package/node_modules/@agenticreplay/adapters/dist/grok.d.ts

@@ -0,0 +1,23 @@
+import { HOOK_FILENAME } from '@agenticreplay/node-instrument';
+import type { Adapter } from '@agenticreplay/plugin-api';
+/**
+ * grok-cli — the community coding agent for xAI's Grok API.
+ *
+ * It documents `GROK_BASE_URL` (default `https://api.x.ai/v1`), so the ordinary redirect works and
+ * this adapter is mostly that one variable. Two details are not ordinary:
+ *
+ * The `/v1` is part of the documented default, so the replacement carries it — drop it and every
+ * request lands one path segment short.
+ *
+ * And it runs on Bun with sub-agents on by default. A sub-agent that builds its own client would
+ * slip past a variable its parent read, so the fetch hook goes in as well, with `api.x.ai` added
+ * to the allowlist — it is not one of the hook's default hosts, so without that line the hook
+ * would be installed and inert. Bun ignores `--require` inside `NODE_OPTIONS`, which is why
+ * `BUN_OPTIONS` is set alongside it.
+ *
+ * Its Telegram remote control is the same process reading the same variable, so "the grok bot" is
+ * captured by this adapter too, with nothing extra.
+ */
+export declare const grokAdapter: Adapter;
+export { HOOK_FILENAME };
+//# sourceMappingURL=grok.d.ts.map

package/node_modules/@agenticreplay/adapters/dist/grok.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok.d.ts","sourceRoot":"","sources":["../src/grok.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAId,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,2BAA2B,CAAC;AAOhF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,EAAE,OA0BzB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/node_modules/@agenticreplay/adapters/dist/grok.js

@@ -0,0 +1,50 @@
+import { HOOK_FILENAME, bunOptionsWithHook, nodeOptionsWithHook, writeFetchHook, } from '@agenticreplay/node-instrument';
+import { applyNamedBaseUrls, passThrough, proxyBase, readEnv } from './env.js';
+import { detectAgent } from './detect.js';
+/** xAI's origin, which grok-cli reaches whenever something bypasses `GROK_BASE_URL`. */
+const XAI_HOST = 'api.x.ai';
+/**
+ * grok-cli — the community coding agent for xAI's Grok API.
+ *
+ * It documents `GROK_BASE_URL` (default `https://api.x.ai/v1`), so the ordinary redirect works and
+ * this adapter is mostly that one variable. Two details are not ordinary:
+ *
+ * The `/v1` is part of the documented default, so the replacement carries it — drop it and every
+ * request lands one path segment short.
+ *
+ * And it runs on Bun with sub-agents on by default. A sub-agent that builds its own client would
+ * slip past a variable its parent read, so the fetch hook goes in as well, with `api.x.ai` added
+ * to the allowlist — it is not one of the hook's default hosts, so without that line the hook
+ * would be installed and inert. Bun ignores `--require` inside `NODE_OPTIONS`, which is why
+ * `BUN_OPTIONS` is set alongside it.
+ *
+ * Its Telegram remote control is the same process reading the same variable, so "the grok bot" is
+ * captured by this adapter too, with nothing extra.
+ */
+export const grokAdapter = {
+    id: 'grok',
+    aliases: ['grok-cli'],
+    async detect(_cwd) {
+        return detectAgent(['grok'], ['.grok']);
+    },
+    async prepare(ctx) {
+        const hookPath = await writeFetchHook(ctx.runDir);
+        const hosts = readEnv(ctx.env, 'AGENTICREPLAY_INSTRUMENT_HOSTS');
+        const env = {
+            GROK_BASE_URL: proxyBase(ctx.proxyUrl, 'v1'),
+            AGENTICREPLAY_PROXY_URL: ctx.proxyUrl,
+            // Added to whatever the operator asked for rather than replacing it: naming one host should
+            // not silently drop xAI, which is the only host this adapter exists to catch.
+            AGENTICREPLAY_INSTRUMENT_HOSTS: hosts === undefined ? XAI_HOST : `${hosts},${XAI_HOST}`,
+            NODE_OPTIONS: nodeOptionsWithHook(hookPath, readEnv(ctx.env, 'NODE_OPTIONS')),
+            BUN_OPTIONS: bunOptionsWithHook(hookPath, readEnv(ctx.env, 'BUN_OPTIONS')),
+        };
+        // Never invented: grok-cli refuses to start without a key and says so clearly, which is a
+        // better failure than a run that silently authenticates as nobody.
+        passThrough(env, ctx.env, 'GROK_API_KEY');
+        applyNamedBaseUrls(env, ctx.env, ctx.proxyUrl);
+        return { command: 'grok', args: [...ctx.userArgs], env, tempFiles: [hookPath] };
+    },
+};
+export { HOOK_FILENAME };
+//# sourceMappingURL=grok.js.map

package/node_modules/@agenticreplay/adapters/dist/grok.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok.js","sourceRoot":"","sources":["../src/grok.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,GACf,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,wFAAwF;AACxF,MAAM,QAAQ,GAAG,UAAU,CAAC;AAE5B;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAY;IAClC,EAAE,EAAE,MAAM;IACV,OAAO,EAAE,CAAC,UAAU,CAAC;IAErB,KAAK,CAAC,MAAM,CAAC,IAAY;QACvB,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAkB;QAC9B,MAAM,QAAQ,GAAG,MAAM,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAClD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,gCAAgC,CAAC,CAAC;QACjE,MAAM,GAAG,GAA2B;YAClC,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC;YAC5C,uBAAuB,EAAE,GAAG,CAAC,QAAQ;YACrC,4FAA4F;YAC5F,8EAA8E;YAC9E,8BAA8B,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,QAAQ,EAAE;YACvF,YAAY,EAAE,mBAAmB,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;YAC7E,WAAW,EAAE,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;SAC3E,CAAC;QACF,0FAA0F;QAC1F,mEAAmE;QACnE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;QAC1C,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC;IAClF,CAAC;CACF,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/node_modules/@agenticreplay/adapters/dist/hermes.d.ts

@@ -0,0 +1,70 @@
+import type { Adapter } from '@agenticreplay/plugin-api';
+/**
+ * Hermes, Nous Research's agent — the first Python harness agenticreplay records.
+ *
+ * Every other adapter here fronts a Node harness, and that difference is the whole reason this
+ * one exists. Nothing is redirected: `OPENAI_BASE_URL` is not a route into Hermes. Its origin
+ * lives in `config.yaml` under `model.base_url`, and the environment variable is read in only one
+ * place -- an advisory warning that fires when it is set and the provider is *not* `custom`.
+ * Verified against a logging listener rather than inferred: with `model.base_url` pointed at a
+ * dead port and `OPENAI_BASE_URL` at a live one, the run dies on the dead port and the listener
+ * records nothing, `--provider custom` included.
+ *
+ * What does work is the transport. Hermes honours `HTTPS_PROXY` all the way down -- through a
+ * proxy that logs CONNECT targets, a single question sends two of them to the model origin, the
+ * model-catalogue read and the completion -- so `--tls-intercept` reaches it.
+ *
+ * TLS trust is process-local. Standard Python clients use SSL_CERT_FILE; current Hermes
+ * additionally uses OS-backed truststore contexts that ignore that variable. The recording
+ * bootstrap adds the run CA to those contexts, preserving platform roots and certificate
+ * verification. No system trust store or Hermes configuration is modified.
+ *
+ * `inference-api.nousresearch.com` is in `DEFAULT_TLS_HOSTS`, so Hermes on Nous' own models needs
+ * no extra `--tls-hosts`. Deliberately not in that list: `portal.nousresearch.com`, which is
+ * billing and subscription management and where the API key is issued.
+ *
+ * The fixture below was verified against `--provider opencode-free`, whose tier is served
+ * anonymously -- no key, so no credential to leak into a recording. That origin needs
+ * `--tls-hosts '+opencode.ai'` and does not get a default entry: unlike `api.kilo.ai` or
+ * `api.xiaomimimo.com` it is a website as much as a gateway, and a default that decrypted it would
+ * decrypt whatever else is served there.
+ *
+ *     agenticreplay record hermes --tls-intercept --tls-hosts '+opencode.ai' -- \
+ *       --provider opencode-free -m nemotron-3.5-lightning-free -z 'your question'
+ *
+ * `-z` is the non-interactive flag; without it Hermes opens a session and waits.
+ *
+ * Three things about a Hermes recording that are worth knowing before reading one, all measured
+ * against v0.21.0 rather than reasoned about:
+ *
+ * **It does not work in the directory agenticreplay launched it in.** `_restore_session_cwd` in Hermes'
+ * own CLI chdirs to the cwd stored in its session metadata, so a run started in a project reports
+ * the home directory when asked, and writes land there. Per-turn filesystem diffs are taken of
+ * the directory agenticreplay recorded from, so they read `0 changed` on a run that did change files --
+ * the evidence is still in the trace, as the absolute path inside the `write_file` tool call.
+ * `TERMINAL_CWD` is the lever, and the adapter deliberately does not pull it: forcing it would
+ * make a recorded run write somewhere different from the same command uninstrumented, which is
+ * the one thing an adapter here must never do. Export it yourself when you want the diffs.
+ *
+ * **How much of a multi-turn run replays depends on the recording, not on you.** Hermes makes a
+ * one-message background call and abandons it, and where that lands decides the outcome. Landing
+ * after the turns, a three-exchange recording replays `reused=3/3 exact=3 divergences=0`. Landing
+ * between them, the matcher meets it where the recording has a three-message turn and strict
+ * replay stops at `reused=1/3`; `--loose` carries the run to the same answer. Recording the same
+ * task four times gave two of each, and each recording then replays the same way every time --
+ * deterministic per recording, roughly even across them. The `unmatched=1` is that call in both
+ * cases: the recording holds no answer for it, deliberately, because an exchange with no response
+ * cannot be replayed.
+ *
+ * **The prompt carries Hermes' own skills catalogue, so a short one means a broken install.** It
+ * is 14,058 characters and 19 tools, byte-identical across runs, and about 6,300 of that is an
+ * `<available_skills>` block listing the 51 skills `hermes skills list` calls builtin -- Hermes'
+ * content, not the operator's. A split install can hide it: `HERMES_HOME` is a persisted user
+ * variable here, and a shell whose environment predates the install falls back to a home with no
+ * skills directory, where the same prompt comes out 7,742 characters. That also degrades replay,
+ * from `3/3 exact=3` to `1/3` on the same task -- which is worth knowing, because it looks
+ * exactly like a matcher bug. Check `hermes skills list` first: 0 builtin means the harness cannot
+ * find itself.
+ */
+export declare const hermesAdapter: Adapter;
+//# sourceMappingURL=hermes.d.ts.map

package/node_modules/@agenticreplay/adapters/dist/hermes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes.d.ts","sourceRoot":"","sources":["../src/hermes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,2BAA2B,CAAC;AAGhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,eAAO,MAAM,aAAa,EAAE,OAqB3B,CAAC"}

package/node_modules/@agenticreplay/adapters/dist/hermes.js

@@ -0,0 +1,88 @@
+import { detectAgent } from './detect.js';
+/**
+ * Hermes, Nous Research's agent — the first Python harness agenticreplay records.
+ *
+ * Every other adapter here fronts a Node harness, and that difference is the whole reason this
+ * one exists. Nothing is redirected: `OPENAI_BASE_URL` is not a route into Hermes. Its origin
+ * lives in `config.yaml` under `model.base_url`, and the environment variable is read in only one
+ * place -- an advisory warning that fires when it is set and the provider is *not* `custom`.
+ * Verified against a logging listener rather than inferred: with `model.base_url` pointed at a
+ * dead port and `OPENAI_BASE_URL` at a live one, the run dies on the dead port and the listener
+ * records nothing, `--provider custom` included.
+ *
+ * What does work is the transport. Hermes honours `HTTPS_PROXY` all the way down -- through a
+ * proxy that logs CONNECT targets, a single question sends two of them to the model origin, the
+ * model-catalogue read and the completion -- so `--tls-intercept` reaches it.
+ *
+ * TLS trust is process-local. Standard Python clients use SSL_CERT_FILE; current Hermes
+ * additionally uses OS-backed truststore contexts that ignore that variable. The recording
+ * bootstrap adds the run CA to those contexts, preserving platform roots and certificate
+ * verification. No system trust store or Hermes configuration is modified.
+ *
+ * `inference-api.nousresearch.com` is in `DEFAULT_TLS_HOSTS`, so Hermes on Nous' own models needs
+ * no extra `--tls-hosts`. Deliberately not in that list: `portal.nousresearch.com`, which is
+ * billing and subscription management and where the API key is issued.
+ *
+ * The fixture below was verified against `--provider opencode-free`, whose tier is served
+ * anonymously -- no key, so no credential to leak into a recording. That origin needs
+ * `--tls-hosts '+opencode.ai'` and does not get a default entry: unlike `api.kilo.ai` or
+ * `api.xiaomimimo.com` it is a website as much as a gateway, and a default that decrypted it would
+ * decrypt whatever else is served there.
+ *
+ *     agenticreplay record hermes --tls-intercept --tls-hosts '+opencode.ai' -- \
+ *       --provider opencode-free -m nemotron-3.5-lightning-free -z 'your question'
+ *
+ * `-z` is the non-interactive flag; without it Hermes opens a session and waits.
+ *
+ * Three things about a Hermes recording that are worth knowing before reading one, all measured
+ * against v0.21.0 rather than reasoned about:
+ *
+ * **It does not work in the directory agenticreplay launched it in.** `_restore_session_cwd` in Hermes'
+ * own CLI chdirs to the cwd stored in its session metadata, so a run started in a project reports
+ * the home directory when asked, and writes land there. Per-turn filesystem diffs are taken of
+ * the directory agenticreplay recorded from, so they read `0 changed` on a run that did change files --
+ * the evidence is still in the trace, as the absolute path inside the `write_file` tool call.
+ * `TERMINAL_CWD` is the lever, and the adapter deliberately does not pull it: forcing it would
+ * make a recorded run write somewhere different from the same command uninstrumented, which is
+ * the one thing an adapter here must never do. Export it yourself when you want the diffs.
+ *
+ * **How much of a multi-turn run replays depends on the recording, not on you.** Hermes makes a
+ * one-message background call and abandons it, and where that lands decides the outcome. Landing
+ * after the turns, a three-exchange recording replays `reused=3/3 exact=3 divergences=0`. Landing
+ * between them, the matcher meets it where the recording has a three-message turn and strict
+ * replay stops at `reused=1/3`; `--loose` carries the run to the same answer. Recording the same
+ * task four times gave two of each, and each recording then replays the same way every time --
+ * deterministic per recording, roughly even across them. The `unmatched=1` is that call in both
+ * cases: the recording holds no answer for it, deliberately, because an exchange with no response
+ * cannot be replayed.
+ *
+ * **The prompt carries Hermes' own skills catalogue, so a short one means a broken install.** It
+ * is 14,058 characters and 19 tools, byte-identical across runs, and about 6,300 of that is an
+ * `<available_skills>` block listing the 51 skills `hermes skills list` calls builtin -- Hermes'
+ * content, not the operator's. A split install can hide it: `HERMES_HOME` is a persisted user
+ * variable here, and a shell whose environment predates the install falls back to a home with no
+ * skills directory, where the same prompt comes out 7,742 characters. That also degrades replay,
+ * from `3/3 exact=3` to `1/3` on the same task -- which is worth knowing, because it looks
+ * exactly like a matcher bug. Check `hermes skills list` first: 0 builtin means the harness cannot
+ * find itself.
+ */
+export const hermesAdapter = {
+    id: 'hermes',
+    aliases: ['hermes-agent', 'nous-hermes'],
+    harnessVersions: '>=0.21.0',
+    // Redirecting nothing is the intent, not a defect. See the `capture` field on `Adapter`.
+    capture: 'transport',
+    async detect(_cwd) {
+        // `AppData/Local/hermes` is where the Windows install keeps `config.yaml`; the XDG paths are
+        // the same directory on the other platforms. Home-relative, so an install moved with
+        // `HERMES_HOME` is still found by its binary.
+        return detectAgent(['hermes'], ['AppData/Local/hermes', '.config/hermes', '.hermes']);
+    },
+    async prepare(ctx) {
+        // No origin and no credential. Hermes keeps both in `config.yaml` and its own secret store,
+        // and an adapter that injected either would override a choice made there -- for the origin it
+        // could not anyway, per the note above.
+        return { command: 'hermes', args: [...ctx.userArgs], env: {} };
+    },
+};
+//# sourceMappingURL=hermes.js.map

package/node_modules/@agenticreplay/adapters/dist/hermes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes.js","sourceRoot":"","sources":["../src/hermes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAY;IACpC,EAAE,EAAE,QAAQ;IACZ,OAAO,EAAE,CAAC,cAAc,EAAE,aAAa,CAAC;IACxC,eAAe,EAAE,UAAU;IAE3B,yFAAyF;IACzF,OAAO,EAAE,WAAW;IAEpB,KAAK,CAAC,MAAM,CAAC,IAAY;QACvB,6FAA6F;QAC7F,qFAAqF;QACrF,8CAA8C;QAC9C,OAAO,WAAW,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,sBAAsB,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAC;IACxF,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAkB;QAC9B,4FAA4F;QAC5F,8FAA8F;QAC9F,wCAAwC;QACxC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;IACjE,CAAC;CACF,CAAC"}

package/node_modules/@agenticreplay/adapters/dist/index.d.ts

@@ -0,0 +1,25 @@
+export * from './claude-code.js';
+export * from './codex.js';
+export * from './contract.js';
+export * from './cursor.js';
+export * from './detect.js';
+export * from './env.js';
+export * from './exec.js';
+export * from './generic-openai.js';
+export * from './goose.js';
+export * from './grok.js';
+export * from './hermes.js';
+export * from './indexrag.js';
+export * from './node.js';
+export * from './openclaw.js';
+export * from './mcp-config.js';
+export * from './kilo.js';
+export * from './mcode.js';
+export * from './mimo.js';
+export * from './opencode.js';
+export * from './qwen.js';
+export * from './registry.js';
+export * from './scaffold.js';
+export * from './session.js';
+export * from './zcode.js';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@agenticreplay/adapters/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/node_modules/@agenticreplay/adapters/dist/index.js

@@ -0,0 +1,25 @@
+export * from './claude-code.js';
+export * from './codex.js';
+export * from './contract.js';
+export * from './cursor.js';
+export * from './detect.js';
+export * from './env.js';
+export * from './exec.js';
+export * from './generic-openai.js';
+export * from './goose.js';
+export * from './grok.js';
+export * from './hermes.js';
+export * from './indexrag.js';
+export * from './node.js';
+export * from './openclaw.js';
+export * from './mcp-config.js';
+export * from './kilo.js';
+export * from './mcode.js';
+export * from './mimo.js';
+export * from './opencode.js';
+export * from './qwen.js';
+export * from './registry.js';
+export * from './scaffold.js';
+export * from './session.js';
+export * from './zcode.js';
+//# sourceMappingURL=index.js.map

package/node_modules/@agenticreplay/adapters/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/node_modules/@agenticreplay/adapters/dist/indexrag.d.ts

@@ -0,0 +1,27 @@
+import type { Adapter } from '@agenticreplay/plugin-api';
+/**
+ * IndexRAG — a retrieval pipeline rather than a conversational agent.
+ *
+ * It is the first adapter for a harness of this shape, and the shape is what makes it worth
+ * having its own rather than running it under `generic-openai`. Three things are different:
+ *
+ * **Two model origins in one run.** Chat (extraction, bridging, answering) reads
+ * `OPENAI_BASE_URL`; embeddings read `INDEXRAG_EMBEDDING_BASE_URL` and may point at a completely
+ * different provider — a dedicated embedding vendor, or a local Ollama. AgenticReplay's upstream map is
+ * keyed by wire dialect, so no `--upstream-*` can express "the same dialect at two origins"; the
+ * second one is redirected through `/forward/`, which carries its own destination on the request.
+ *
+ * **The product is not the working tree.** What a run produces is `cache/` and `vector_store/`,
+ * both on the first two lines of IndexRAG's own `.gitignore`. Without `artifacts.capture` a
+ * recording holds every call that built an index and no trace of the index.
+ *
+ * **It resumes.** Run again over a finished cache and it asks nothing at all — which on replay
+ * means a recording that reproduces perfectly by doing nothing. `artifacts.resetBeforeReplay`
+ * puts the workspace back to where the recording began.
+ *
+ * Nothing here is IndexRAG-specific except the names: the same three declarations describe
+ * LlamaIndex, Microsoft GraphRAG and LightRAG, which is why they are declarations rather than
+ * code.
+ */
+export declare const indexRagAdapter: Adapter;
+//# sourceMappingURL=indexrag.d.ts.map

package/node_modules/@agenticreplay/adapters/dist/indexrag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexrag.d.ts","sourceRoot":"","sources":["../src/indexrag.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,2BAA2B,CAAC;AAUhF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,eAAe,EAAE,OAoG7B,CAAC"}

package/node_modules/@agenticreplay/adapters/dist/indexrag.js

@@ -0,0 +1,236 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { applyNamedBaseUrls, forwardOrProxyBase, passKey, passThrough, proxyBase, readEnv, } from './env.js';
+/**
+ * IndexRAG — a retrieval pipeline rather than a conversational agent.
+ *
+ * It is the first adapter for a harness of this shape, and the shape is what makes it worth
+ * having its own rather than running it under `generic-openai`. Three things are different:
+ *
+ * **Two model origins in one run.** Chat (extraction, bridging, answering) reads
+ * `OPENAI_BASE_URL`; embeddings read `INDEXRAG_EMBEDDING_BASE_URL` and may point at a completely
+ * different provider — a dedicated embedding vendor, or a local Ollama. AgenticReplay's upstream map is
+ * keyed by wire dialect, so no `--upstream-*` can express "the same dialect at two origins"; the
+ * second one is redirected through `/forward/`, which carries its own destination on the request.
+ *
+ * **The product is not the working tree.** What a run produces is `cache/` and `vector_store/`,
+ * both on the first two lines of IndexRAG's own `.gitignore`. Without `artifacts.capture` a
+ * recording holds every call that built an index and no trace of the index.
+ *
+ * **It resumes.** Run again over a finished cache and it asks nothing at all — which on replay
+ * means a recording that reproduces perfectly by doing nothing. `artifacts.resetBeforeReplay`
+ * puts the workspace back to where the recording began.
+ *
+ * Nothing here is IndexRAG-specific except the names: the same three declarations describe
+ * LlamaIndex, Microsoft GraphRAG and LightRAG, which is why they are declarations rather than
+ * code.
+ */
+export const indexRagAdapter = {
+    id: 'indexrag',
+    harnessVersions: '>=0.1.0 <0.2',
+    capture: 'env',
+    /**
+     * The source tree, not an installed package.
+     *
+     * IndexRAG's wheel does not carry `indexrag/aku/prompts/*.md`, so a `pip install`ed copy cannot
+     * extract anything — and the pipeline this adapter drives is run from a checkout in every
+     * documented usage. Two files rather than one: a directory called `indexrag` is a common enough
+     * name that a single probe would claim someone else's workspace.
+     */
+    async detect(cwd) {
+        try {
+            return (existsSync(join(cwd, 'indexrag', 'aku', 'extractor.py')) &&
+                existsSync(join(cwd, 'scripts', 'build_kb.py')));
+        }
+        catch {
+            return false;
+        }
+    },
+    async prepare(ctx) {
+        const env = {
+            // Three `openai.OpenAI()` call sites — extraction, bridging, answer generation — and
+            // langchain's default embedding path, which reads the second spelling.
+            OPENAI_BASE_URL: proxyBase(ctx.proxyUrl, 'v1'),
+            OPENAI_API_BASE: proxyBase(ctx.proxyUrl, 'v1'),
+        };
+        passKey(env, ctx.env, 'OPENAI_API_KEY');
+        // No `ANTHROPIC_*`: every stage speaks OpenAI, and inventing an Anthropic credential is how
+        // a harness that picks its provider from what it can see picks a different one under
+        // recording. See the contract's `no-invented-keys`.
+        // The second origin. Redirected without its original target it would be forwarded to the chat
+        // upstream — a model that endpoint has never heard of, with the embedding provider's key on
+        // it; left alone it bypasses agenticreplay entirely and not even a `net.*` pair reaches the trace.
+        //
+        // Read from the environment *or* from the project's own `.env`, because that is where
+        // IndexRAG documents it: `indexrag/config.py` loads `.env` from the working directory before
+        // anything reads configuration, and `.env.example` is the file people copy. An adapter that
+        // only looked at `ctx.env` would leave the variable unset here, let Python pick the real
+        // origin up a moment later, and record nothing of the embedding half — the silent capture gap
+        // this whole file exists to close. The environment still wins, exactly as it does in
+        // `config.py`.
+        const embedding = readEnv(ctx.env, 'INDEXRAG_EMBEDDING_BASE_URL') ??
+            dotEnv(ctx.cwd)['INDEXRAG_EMBEDDING_BASE_URL'];
+        if (embedding !== undefined) {
+            // Through the same gate as every other named origin: a base URL the `/forward/` decoder
+            // will not accept must not become a `/forward/` path. See `forwardOrProxyBase`.
+            env.INDEXRAG_EMBEDDING_BASE_URL = forwardOrProxyBase(ctx.proxyUrl, embedding);
+        }
+        passThrough(env, ctx.env, 'INDEXRAG_EMBEDDING_API_KEY');
+        passThrough(env, ctx.env, 'INDEXRAG_EMBEDDING_PROVIDER');
+        passThrough(env, ctx.env, 'INDEXRAG_EMBEDDING_MODEL');
+        passThrough(env, ctx.env, 'INDEXRAG_LLM_MODEL');
+        // A harness the author has not met is the normal case even inside one project: someone
+        // pointing a rerank service or a second gateway somewhere still gets a way to name it.
+        applyNamedBaseUrls(env, ctx.env, ctx.proxyUrl);
+        // A command the user spelled out wins. `agenticreplay record indexrag -- python -m benchmarks.evaluate
+        // --dataset mini` records exactly that one stage, which is what someone debugging the query
+        // half wants; anything starting with `-` is an argument to the pipeline, not a program.
+        const [first, ...rest] = ctx.userArgs;
+        if (first !== undefined && first !== '' && !first.startsWith('-')) {
+            return { command: first, args: rest, env };
+        }
+        // Otherwise: the whole pipeline, as one recorded run. `agenticreplay record` launches one process and
+        // IndexRAG's stages are four of them, so the stages are driven in-process from a script
+        // written into the run directory — which the contract's `no-foreign-paths` allows precisely
+        // so an adapter can do this reproducibly.
+        const driver = join(ctx.runDir, DRIVER_FILENAME);
+        await writeFile(driver, PIPELINE_DRIVER, 'utf8');
+        return { command: 'python', args: [driver, ...ctx.userArgs], env, tempFiles: [driver] };
+    },
+    artifacts: {
+        // The index, the caches it is built from, and the corpus it is built *of*. IndexRAG's
+        // `.gitignore` excludes all three — `vector_store/`, `cache/` and `dataset/` are its first
+        // three data lines — so without this a recording holds every call the run made and neither
+        // its input nor its output.
+        //
+        // `dataset` is the one that looks optional and is not. A replay in the recording's own
+        // directory finds it already there, which is why this was easy to miss; a replay anywhere
+        // else — `--worktree`, another machine — starts with no documents to chunk and reproduces
+        // nothing, `reused=0/11 exit=2`, over a recording that was perfectly good. It is the input
+        // the run read, and a recording that cannot be read without the reader's own disk is not a
+        // recording. The cost is real for a large corpus, and `--no-fs` is the way to decline it.
+        capture: ['cache', 'vector_store', 'dataset', 'test_results_*.json'],
+        // Whole directories, never "the valid parts". IndexRAG's resume skips by `chunk_id`, and the
+        // cache holds `success: false` entries in the same shape as successes — so keeping what looks
+        // valid promotes the previous run's failures to completed work, which is a worse wrong answer
+        // than the one being fixed.
+        resetBeforeReplay: ['cache', 'vector_store'],
+        concurrencyFlag: { flag: '--concurrency', serialValue: '1' },
+    },
+};
+const DRIVER_FILENAME = 'drive_indexrag.py';
+/**
+ * The project's own `.env`, read the way `indexrag/config.py` reads it.
+ *
+ * Only for looking things up — nothing here is copied into the child, which would turn a file
+ * Python is about to read for itself into a second, diverging source of truth. What it is for is
+ * the one variable agenticreplay has to know *before* the harness starts: the embedding origin, which
+ * decides whether that half of the run is captured at all.
+ *
+ * Deliberately the same small parser: `KEY=VALUE`, `#` comments, optional surrounding quotes, an
+ * optional `export ` prefix. An unreadable or absent file is not an error — it is the ordinary
+ * case for someone who configured everything through their shell.
+ */
+function dotEnv(cwd) {
+    let text;
+    try {
+        text = readFileSync(join(cwd, '.env'), 'utf8');
+    }
+    catch {
+        return {};
+    }
+    const out = {};
+    for (const raw of text.replace(/^/, '').split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line === '' || line.startsWith('#') || !line.includes('='))
+            continue;
+        const at = line.indexOf('=');
+        const key = line
+            .slice(0, at)
+            .trim()
+            .replace(/^export\s+/, '');
+        let value = line.slice(at + 1).trim();
+        if (value.length >= 2 &&
+            value[0] === value[value.length - 1] &&
+            (value[0] === '"' || value[0] === "'")) {
+            value = value.slice(1, -1);
+        }
+        if (key !== '' && value !== '')
+            out[key] = value;
+    }
+    return out;
+}
+/**
+ * The pipeline, as one process.
+ *
+ * `runpy` rather than four subprocesses: `agenticreplay record` launches one child and watches it, so four
+ * children would be four recordings or none. Running the stages in-process keeps them in one
+ * trace, in order, with the filesystem snapshots between turns showing the cache and the index
+ * appearing.
+ *
+ * The arguments it accepts are the ones that change what the run *does*. Everything else is
+ * IndexRAG's own default, because an adapter that re-declares a harness's defaults is an adapter
+ * that goes stale the first time one of them changes.
+ */
+const PIPELINE_DRIVER = `"""Drive IndexRAG's stages as one recorded run.
+
+Written by the AgenticReplay 'indexrag' adapter into the run directory. Not part of IndexRAG.
+"""
+
+import argparse
+import runpy
+import sys
+from pathlib import Path
+
+# The stages are 'scripts.*' and 'benchmarks.*', which resolve against the working directory --
+# and sys.path[0] is this script's directory, not the workspace, because that is how Python
+# starts a file by path. Without this every stage fails on 'No module named scripts'.
+sys.path.insert(0, str(Path.cwd()))
+
+parser = argparse.ArgumentParser(prog="drive_indexrag")
+parser.add_argument("--data-dir", required=True, help="Directory with the .txt documents")
+parser.add_argument("--suffix", default=None, help="Cache file suffix")
+parser.add_argument("--concurrency", type=int, default=None)
+parser.add_argument("--model", default=None, help="Chat model for extraction and bridging")
+parser.add_argument("--kb-type", default="indexrag", choices=["indexrag", "naive"])
+parser.add_argument("--top-k", type=int, default=None)
+parser.add_argument("--skip-eval", action="store_true", help="Index only; do not answer questions")
+args = parser.parse_args()
+
+data_dir = Path(args.data_dir)
+dataset = data_dir.parent.name
+suffix = f"_{args.suffix}" if args.suffix else ""
+cache = Path("cache") / f"{dataset}{suffix}_faqs.json"
+bridging = cache.with_name(f"{cache.stem}_bridging.json")
+
+shared = []
+if args.concurrency is not None:
+    shared += ["--concurrency", str(args.concurrency)]
+model = ["--model", args.model] if args.model else []
+
+
+def stage(module, *argv):
+    print(f"\\n=== {module} ===", flush=True)
+    sys.argv = [module, *argv]
+    runpy.run_module(module, run_name="__main__")
+
+
+stage("scripts.extract_akus", "--data-dir", str(data_dir),
+      *(["--suffix", args.suffix] if args.suffix else []), *shared, *model)
+stage("scripts.generate_bridging", "--cache", str(cache), *shared, *model)
+
+build = ["--data-dir", str(data_dir), "--kb-type", args.kb_type, "--cache", str(cache)]
+if bridging.exists():
+    build += ["--bridging", str(bridging)]
+stage("scripts.build_kb", *build)
+
+questions = data_dir.parent / "questions.json"
+if not args.skip_eval and questions.exists():
+    stage("benchmarks.evaluate", "--dataset", dataset, "--kb-type", args.kb_type,
+          *(["--top-k", str(args.top_k)] if args.top_k is not None else []),
+          *(["--llm-model", args.model] if args.model else []))
+elif not args.skip_eval:
+    print(f"\\nno {questions}; indexed but not evaluated", flush=True)
+`;
+//# sourceMappingURL=indexrag.js.map

package/node_modules/@agenticreplay/adapters/dist/indexrag.js.map

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

package/node_modules/@agenticreplay/adapters/dist/kilo.d.ts

@@ -0,0 +1,21 @@
+import type { Adapter } from '@agenticreplay/plugin-api';
+/**
+ * Kilo Code's CLI — another OpenCode fork, captured the way the others are.
+ *
+ * Nothing is redirected, for the reason the whole OpenCode family shares: the provider origin
+ * lives in the harness's own config rather than in an environment variable, so `OPENAI_BASE_URL`
+ * leaves the run talking straight past the proxy. `--tls-intercept` terminates the TLS the agent
+ * established itself, and `api.kilo.ai` is in `DEFAULT_TLS_HOSTS` so the built-in `kilo/*` models
+ * need no extra `--tls-hosts`.
+ *
+ * One thing worth knowing before recording it: Kilo checks entitlement locally, before it opens a
+ * connection. A model the account cannot use fails with "You need to sign in to use this model"
+ * and no request is ever sent, so there is nothing to capture — unlike MiMo, which sends the
+ * request and lets the server reject it. `kilo/kilo-auto/free` is reachable without a paid plan
+ * and is what the fixture below was verified against.
+ *
+ * Kilo also posts to `us.i.posthog.com`. That is not a model API and is not in the allowlist, so
+ * it stays tunnelled: agenticreplay records that the connection happened and reads none of it.
+ */
+export declare const kiloAdapter: Adapter;
+//# sourceMappingURL=kilo.d.ts.map

package/node_modules/@agenticreplay/adapters/dist/kilo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kilo.d.ts","sourceRoot":"","sources":["../src/kilo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,2BAA2B,CAAC;AAGhF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,EAAE,OAiBzB,CAAC"}