@polydeukes/adapter-claude-code 0.6.1 → 0.8.0

package/dist/session-evidence.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The session evidence builder — one raw PreToolUse payload in, the IR's `session` key out.
+ *
+ * Composes the two readers this package already owns: the JSONL transcript beside the
+ * payload's `transcript_path`, and the spawn sidecar derived from that same location. It
+ * opens the files those readers open and spawns nothing, so the runner receives the host's
+ * session evidence as data and needs no knowledge of the format it was read from.
+ */
+import type { CovenantInput } from '@polydeukes/core';
+/** {@link sessionEvidenceFromPayload} input — one raw PreToolUse payload as a JSON string. */
+export type SessionEvidenceFromPayloadSpec = {
+    rawPayload: string;
+};
+/**
+ * The IR's session evidence, or its absence — what one payload proves about the session it
+ * was made in.
+ */
+export type SessionEvidenceOutcome = CovenantInput['session'];
+/**
+ * Build the session evidence one payload carries, or `undefined`.
+ *
+ * The two absences are two facts. No `transcript_path` is no session, and answering an
+ * empty session there would make every session-free payload register transcript-mod over
+ * nothing. A path that cannot be read is a supplier fault: the lists come back empty and
+ * `evidencePath` stays, so the runner still protects the file the host named while the
+ * witness and every history declaration see an empty session and stay shut.
+ *
+ * An unparseable payload narrows to `undefined`, leaving the parse failure to the
+ * translator's own verdict, and an unreadable transcript narrows to empty lists. A permission
+ * refusal on the sidecar directory propagates, as the channel reader's own rule has it —
+ * swallowing it would report a session that never spawned — so the caller composing this
+ * into a hook keeps it inside its fail-closed catch.
+ */
+export declare function sessionEvidenceFromPayload(spec: SessionEvidenceFromPayloadSpec): SessionEvidenceOutcome;

package/dist/session-evidence.js

@@ -0,0 +1,46 @@
+/**
+ * The session evidence builder — one raw PreToolUse payload in, the IR's `session` key out.
+ *
+ * Composes the two readers this package already owns: the JSONL transcript beside the
+ * payload's `transcript_path`, and the spawn sidecar derived from that same location. It
+ * opens the files those readers open and spawns nothing, so the runner receives the host's
+ * session evidence as data and needs no knowledge of the format it was read from.
+ */
+import { sessionChannelReader } from './session-channel-reader.js';
+import { transcriptPathFromPayload } from './session-vocabulary.js';
+import { transcriptFromJsonlFile } from './transcript.js';
+/**
+ * Build the session evidence one payload carries, or `undefined`.
+ *
+ * The two absences are two facts. No `transcript_path` is no session, and answering an
+ * empty session there would make every session-free payload register transcript-mod over
+ * nothing. A path that cannot be read is a supplier fault: the lists come back empty and
+ * `evidencePath` stays, so the runner still protects the file the host named while the
+ * witness and every history declaration see an empty session and stay shut.
+ *
+ * An unparseable payload narrows to `undefined`, leaving the parse failure to the
+ * translator's own verdict, and an unreadable transcript narrows to empty lists. A permission
+ * refusal on the sidecar directory propagates, as the channel reader's own rule has it —
+ * swallowing it would report a session that never spawned — so the caller composing this
+ * into a hook keeps it inside its fail-closed catch.
+ */
+export function sessionEvidenceFromPayload(spec) {
+    const evidencePath = transcriptPathFromPayload({ rawPayload: spec.rawPayload });
+    if (evidencePath === undefined)
+        return undefined;
+    const transcript = transcriptFromJsonlFile({ path: evidencePath });
+    const sidecar = sessionChannelReader({ transcriptPath: evidencePath })('sidecar');
+    return {
+        evidencePath,
+        userMessages: (transcript?.findUserMessages() ?? []).map((message) => ({
+            text: message.text,
+            ...(message.timestampMs === undefined ? {} : { timestampMs: message.timestampMs }),
+        })),
+        toolCalls: (transcript?.findToolCalls() ?? []).map((call) => ({
+            name: call.name,
+            args: call.args,
+            ...(call.succeeded === undefined ? {} : { succeeded: call.succeeded }),
+        })),
+        ...(sidecar === undefined ? {} : { channels: { sidecar } }),
+    };
+}

package/dist/session-vocabulary.d.ts

@@ -30,6 +30,6 @@ export type TranscriptPathFromPayloadSpec = {
  * (unparseable JSON, a non-object payload, a non-string field), never a throw: lost
  * evidence leaves the dispatcher on its `noopTranscript` default, which shuts the
  * witness valve rather than opening it. A payload this function
- * cannot parse is still dispatched — `runAdapterPath` owns that verdict.
+ * cannot parse is still dispatched — the spawned judge owns that verdict.
  */
 export declare function transcriptPathFromPayload(spec: TranscriptPathFromPayloadSpec): string | undefined;

package/dist/session-vocabulary.js

@@ -27,7 +27,7 @@ export const COMMAND_ARGS = ['command'];
  * (unparseable JSON, a non-object payload, a non-string field), never a throw: lost
  * evidence leaves the dispatcher on its `noopTranscript` default, which shuts the
  * witness valve rather than opening it. A payload this function
- * cannot parse is still dispatched — `runAdapterPath` owns that verdict.
+ * cannot parse is still dispatched — the spawned judge owns that verdict.
  */
 export function transcriptPathFromPayload(spec) {
     let parsed;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@polydeukes/adapter-claude-code",
-  "version": "0.6.1",
-  "description": "Polydeukes adapter for Claude Code — up-translates PreToolUse hook payloads into the agent-neutral covenant input IR. Alpha.",
+  "version": "0.8.0",
+  "description": "Polydeukes adapter for Claude Code — up-translates PreToolUse hook payloads into the agent-neutral covenant input IR. Beta.",
+  "author": "huskyhoochu <dfg1499@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -12,6 +13,9 @@
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "pdks-claude-code": "./dist/bin.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -31,11 +35,12 @@
   "devDependencies": {
     "@types/node": "^24.0.0",
     "typescript": "7.0.2",
-    "vitest": "^4.1.0",
-    "@polydeukes/core": "^0.6.1"
+    "vitest": "^5.0.0",
+    "@polydeukes/core": "^0.8.0"
   },
   "peerDependencies": {
-    "@polydeukes/core": "^0.6.1"
+    "@polydeukes/core": "^0.8.0",
+    "polydeukes": "^0.8.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",

package/dist/run-adapter-path.d.ts

@@ -1,53 +0,0 @@
-/**
- * `runAdapterPath` — the adapter path's single wiring entry point.
- *
- * Composes translation → injected dispatch → funnel-supplement recording so every
- * adapter-path call leaves exactly one telemetry row when summed with downstream
- * records. I/O lives here and only here — the translation modules stay pure.
- */
-import { type DispatchOutcome } from '@polydeukes/core';
-/**
- * The part of a dispatch result this path reads — a structural view, not a second protocol.
- *
- * Derived from core's `DispatchOutcome` by `Pick`, so it cannot drift from the protocol type:
- * a field renamed there stops compiling here. It is narrower on purpose — the entries carry
- * a telemetry word this path never reads, and demanding it would make every dispatcher the
- * adapter accepts name a core type its own consumers may not be able to resolve.
- */
-export type DispatchAdapterView = {
-    exitCode: DispatchOutcome['exitCode'];
-    results: readonly unknown[];
-};
-/** {@link runAdapterPath} input — one payload, where to record, and the dispatch seam. */
-export type RunAdapterPathSpec = {
-    /** Raw hook stdin — one PreToolUse payload as a JSON string. */
-    rawPayload: string;
-    /** Where adapter-level records append. */
-    telemetryPath: string;
-    /**
-     * Injected dispatch seam — the assembler binds the real dispatcher here.
-     *
-     * Typed by what this path reads, not by what the dispatcher returns: the supplement rule
-     * below needs the exit code and whether any covenant produced an entry. A dispatcher
-     * carrying more per entry — core's `DispatchOutcome`, which adds the telemetry word the
-     * wrapper already recorded — satisfies this structurally, so binding one costs no cast.
-     */
-    dispatch: (stdinPayload: string) => Promise<DispatchAdapterView>;
-    /** Label for adapter-level records. Default: 'adapter-claude-code'. */
-    adapterLabel?: string;
-};
-/** {@link runAdapterPath} result — the exit code the hook process leaves with. */
-export type AdapterPathOutcome = {
-    exitCode: 0 | 2;
-};
-/**
- * Run one PreToolUse payload through the adapter path.
- *
- * Fail-closed on the verdict axis: an unparseable payload, a classification failure,
- * or a rejecting dispatch all resolve to `{ exitCode: 2 }` with one adapter `blocked`
- * record — never a thrown error (an unhandled rejection would exit the hook
- * non-blocking, a bypass vector). The funnel supplement is the exact rule
- * `exitCode 0 && results.length 0 → one adapter passed record`; every other outcome
- * appends nothing because downstream already recorded, so nothing double-counts.
- */
-export declare function runAdapterPath(spec: RunAdapterPathSpec): Promise<AdapterPathOutcome>;

package/dist/run-adapter-path.js

@@ -1,88 +0,0 @@
-/**
- * `runAdapterPath` — the adapter path's single wiring entry point.
- *
- * Composes translation → injected dispatch → funnel-supplement recording so every
- * adapter-path call leaves exactly one telemetry row when summed with downstream
- * records. I/O lives here and only here — the translation modules stay pure.
- */
-import { readFileSync } from 'node:fs';
-import { appendRecordFailOpen, EXIT_BREAK_BLOCKING, EXIT_UPHOLD, } from '@polydeukes/core';
-import { collectFileChanges } from './file-changes.js';
-import { buildCovenantInput } from './up-translate.js';
-/** Default label for adapter-level telemetry records. */
-const DEFAULT_ADAPTER_LABEL = 'adapter-claude-code';
-/**
- * Real-fs pre-state reader for fileChanges — `null` only for true absence (ENOENT).
- *
- * Any other read failure (permissions, a directory target, fd exhaustion) throws:
- * `null` is the IR's creation sentinel, and a poisoned `pre: null` on an existing
- * file would let a path-family discipline uphold the overwrite (fail-open). The
- * caller converts the throw into one adapter `blocked` record.
- */
-function readPreStateFromDisk(filePath) {
-    try {
-        return readFileSync(filePath, 'utf-8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return null;
-        throw error;
-    }
-}
-/**
- * Run one PreToolUse payload through the adapter path.
- *
- * Fail-closed on the verdict axis: an unparseable payload, a classification failure,
- * or a rejecting dispatch all resolve to `{ exitCode: 2 }` with one adapter `blocked`
- * record — never a thrown error (an unhandled rejection would exit the hook
- * non-blocking, a bypass vector). The funnel supplement is the exact rule
- * `exitCode 0 && results.length 0 → one adapter passed record`; every other outcome
- * appends nothing because downstream already recorded, so nothing double-counts.
- */
-export async function runAdapterPath(spec) {
-    const label = spec.adapterLabel ?? DEFAULT_ADAPTER_LABEL;
-    const blockAndRecord = () => {
-        appendRecordFailOpen(spec.telemetryPath, { event: 'blocked', label, subject: '-' });
-        return { exitCode: EXIT_BREAK_BLOCKING };
-    };
-    let payload;
-    try {
-        payload = JSON.parse(spec.rawPayload);
-    }
-    catch {
-        return blockAndRecord();
-    }
-    const built = buildCovenantInput([payload]);
-    if (built.ok !== true) {
-        return blockAndRecord();
-    }
-    // Attach pre/post evidence to the call it belongs to — this path translates
-    // exactly one payload, so the one evidence rides toolCalls[0]. Attached
-    // only when provable: a non-mutating payload leaves its call unproven. A pre-state
-    // read failure that is not absence blocks: evidence that cannot be gathered must not
-    // dispatch a shape that reads as creation.
-    let evidence;
-    try {
-        evidence = collectFileChanges(payload, readPreStateFromDisk);
-    }
-    catch {
-        return blockAndRecord();
-    }
-    const input = evidence === null
-        ? built.value
-        : {
-            ...built.value,
-            toolCalls: built.value.toolCalls.map((call, index) => index === 0 ? { ...call, fileChange: evidence } : call),
-        };
-    let outcome;
-    try {
-        outcome = await spec.dispatch(JSON.stringify(input));
-    }
-    catch {
-        return blockAndRecord();
-    }
-    if (outcome.exitCode === EXIT_UPHOLD && outcome.results.length === 0) {
-        appendRecordFailOpen(spec.telemetryPath, { event: 'passed', label, subject: '-' });
-    }
-    return { exitCode: outcome.exitCode };
-}