@agentwhy/cli 0.0.0-dev

package/dist/adapter/claude-code/probe/collectors/tool-use-collector.js

@@ -0,0 +1,24 @@
+import { Counter } from '../../../../shared/counter.js';
+import { toLabel } from '../../../../shared/label.js';
+import { AGENT_TOOL, FIELDS } from '../../contract/fields.js';
+import { toolUseBlocks } from '../transcript-line.js';
+export class ToolUseCollector {
+    #tools = new Counter();
+    #agentToolUses = 0;
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        for (const block of toolUseBlocks(json)) {
+            const name = block[FIELDS.toolName];
+            this.#tools.add(toLabel(name));
+            if (name === AGENT_TOOL.name)
+                this.#agentToolUses += 1;
+        }
+    }
+    tools() {
+        return this.#tools.toCounts();
+    }
+    agentToolUses() {
+        return this.#agentToolUses;
+    }
+}

package/dist/adapter/claude-code/probe/collectors/tool-version-collector.js

@@ -0,0 +1,14 @@
+import { Counter } from '../../../../shared/counter.js';
+import { toLabel } from '../../../../shared/label.js';
+import { FIELDS } from '../../contract/fields.js';
+export class ToolVersionCollector {
+    #versions = new Counter();
+    collect({ json }) {
+        const version = json?.[FIELDS.toolVersion];
+        if (version !== undefined)
+            this.#versions.add(toLabel(version));
+    }
+    counts() {
+        return this.#versions.toCounts();
+    }
+}

package/dist/adapter/claude-code/probe/collectors/top-level-key-collector.js

@@ -0,0 +1,14 @@
+import { Counter } from '../../../../shared/counter.js';
+import { toLabel } from '../../../../shared/label.js';
+export class TopLevelKeyCollector {
+    #keys = new Counter();
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        for (const key of Object.keys(json))
+            this.#keys.add(toLabel(key));
+    }
+    counts() {
+        return this.#keys.toCounts();
+    }
+}

package/dist/adapter/claude-code/probe/collectors/unknown-line-type-key-collector.js

@@ -0,0 +1,24 @@
+import { byString } from '../../../../shared/compare.js';
+import { Counter } from '../../../../shared/counter.js';
+import { toLabel } from '../../../../shared/label.js';
+import { FIELDS } from '../../contract/fields.js';
+import { classifyLineType } from '../../contract/line-types.js';
+/** Top-level keys per unknown line type, so a new type is classified from what it carries instead of guessed. */
+export class UnknownLineTypeKeyCollector {
+    #keysByType = new Map();
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        const type = json[FIELDS.lineType];
+        if (classifyLineType(type) !== 'unknown')
+            return;
+        const label = toLabel(type);
+        const keys = this.#keysByType.get(label) ?? new Counter();
+        this.#keysByType.set(label, keys);
+        for (const key of Object.keys(json))
+            keys.add(toLabel(key));
+    }
+    keysByType() {
+        return Object.fromEntries([...this.#keysByType.entries()].sort(([a], [b]) => byString(a, b)).map(([type, keys]) => [type, keys.toCounts()]));
+    }
+}

package/dist/adapter/claude-code/probe/collectors/working-directory-collector.js

@@ -0,0 +1,28 @@
+import { FIELDS } from '../../contract/fields.js';
+/**
+ * How many different working directories a session's lines carry - the number, never the directories. A `cwd` is
+ * a path from someone's machine, so it is content, and `doctor` reports counts and key names only (lesson L009).
+ * How many lines carry the field at all is already in `topLevelKeys`; this measures what that cannot.
+ *
+ * One value is the ordinary case, and it is the project root a report can make paths relative to. More than one
+ * means no single root describes the session, which is a variant nothing has measured yet - so it is reported
+ * rather than resolved by picking one.
+ */
+export class WorkingDirectoryCollector {
+    #values = new Set();
+    #invalid = 0;
+    collect({ json }) {
+        if (json === undefined)
+            return;
+        const value = json[FIELDS.workingDirectory];
+        if (value === undefined)
+            return;
+        if (typeof value === 'string')
+            this.#values.add(value);
+        else
+            this.#invalid += 1;
+    }
+    stats() {
+        return { distinct: this.#values.size, invalid: this.#invalid };
+    }
+}

package/dist/adapter/claude-code/probe/doctor-report.js

@@ -0,0 +1 @@
+export {};

package/dist/adapter/claude-code/probe/meta-tally.js

@@ -0,0 +1,42 @@
+import { Counter } from '../../../shared/counter.js';
+import { parseJsonObject } from '../../../shared/json.js';
+import { toLabel } from '../../../shared/label.js';
+import { META_FIELD } from '../contract/fields.js';
+/** Statistics over the meta.json files of a session's subagents. */
+export class MetaTally {
+    #files = 0;
+    #unreadableFiles = 0;
+    #unparsableFiles = 0;
+    #keys = new Counter();
+    #agentType = new Counter();
+    #spawnDepth = new Counter();
+    #requestShape = new Counter();
+    recordUnreadableFile() {
+        this.#files += 1;
+        this.#unreadableFiles += 1;
+    }
+    recordFile(text) {
+        this.#files += 1;
+        const meta = parseJsonObject(text);
+        if (meta === undefined) {
+            this.#unparsableFiles += 1;
+            return;
+        }
+        for (const key of Object.keys(meta))
+            this.#keys.add(toLabel(key));
+        this.#agentType.add(toLabel(meta[META_FIELD.agentType]));
+        this.#spawnDepth.add(toLabel(meta[META_FIELD.spawnDepth]));
+        this.#requestShape.add(toLabel(meta[META_FIELD.requestShape]));
+    }
+    toStats() {
+        return {
+            files: this.#files,
+            unreadableFiles: this.#unreadableFiles,
+            unparsableFiles: this.#unparsableFiles,
+            keys: this.#keys.toCounts(),
+            agentType: this.#agentType.toCounts(),
+            spawnDepth: this.#spawnDepth.toCounts(),
+            requestShape: this.#requestShape.toCounts(),
+        };
+    }
+}

package/dist/adapter/claude-code/probe/session-probe.js

@@ -0,0 +1 @@
+export {};

package/dist/adapter/claude-code/probe/session-tally.js

@@ -0,0 +1,41 @@
+import { AgentToolInputKeyCollector } from './collectors/agent-tool-input-key-collector.js';
+import { DenialKindCollector } from './collectors/denial-kind-collector.js';
+import { TaskNotificationCollector } from './collectors/task-notification-collector.js';
+import { ToolResultReferenceCollector } from './collectors/tool-result-reference-collector.js';
+import { ToolVersionCollector } from './collectors/tool-version-collector.js';
+import { WorkingDirectoryCollector } from './collectors/working-directory-collector.js';
+/** Measurements that span the whole session: every transcript, main and subagents alike, feeds the same collectors. */
+export class SessionTally {
+    #toolVersions = new ToolVersionCollector();
+    #agentToolInputKeys = new AgentToolInputKeyCollector();
+    #denialKinds = new DenialKindCollector();
+    #toolResultReferences = new ToolResultReferenceCollector();
+    #workingDirectories = new WorkingDirectoryCollector();
+    #taskNotifications = new TaskNotificationCollector();
+    collectors = [
+        this.#toolVersions,
+        this.#agentToolInputKeys,
+        this.#denialKinds,
+        this.#toolResultReferences,
+        this.#workingDirectories,
+        this.#taskNotifications,
+    ];
+    toolVersions() {
+        return this.#toolVersions.counts();
+    }
+    workingDirectories() {
+        return this.#workingDirectories.stats();
+    }
+    agentToolInputKeys() {
+        return this.#agentToolInputKeys.counts();
+    }
+    denials() {
+        return this.#denialKinds.stats();
+    }
+    taskNotifications() {
+        return this.#taskNotifications.stats();
+    }
+    toolResultReferences(availableFiles) {
+        return this.#toolResultReferences.stats(availableFiles);
+    }
+}

package/dist/adapter/claude-code/probe/transcript-line.js

@@ -0,0 +1,30 @@
+import { isJsonObject } from '../../../shared/json.js';
+import { FIELDS, TEXT_BLOCK_TYPE, TOOL_RESULT_BLOCK_TYPE, TOOL_USE_BLOCK_TYPE } from '../contract/fields.js';
+export function contentBlocks(line) {
+    const message = line[FIELDS.message];
+    const content = isJsonObject(message) ? message[FIELDS.messageContent] : undefined;
+    return Array.isArray(content) ? content.filter(isJsonObject) : [];
+}
+export function toolUseBlocks(line) {
+    return contentBlocks(line).filter((block) => block[FIELDS.blockType] === TOOL_USE_BLOCK_TYPE);
+}
+/**
+ * The words on a line that holds no tool result - its content as a string, or the text of its text blocks - where a
+ * report delivered late is written. Undefined for a line carrying a result, or no words.
+ */
+export function wordsWithoutResult(line) {
+    const message = line[FIELDS.message];
+    const content = isJsonObject(message) ? message[FIELDS.messageContent] : undefined;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return undefined;
+    const blocks = content.filter(isJsonObject);
+    if (blocks.some((block) => block[FIELDS.blockType] === TOOL_RESULT_BLOCK_TYPE))
+        return undefined;
+    const words = blocks
+        .filter((block) => block[FIELDS.blockType] === TEXT_BLOCK_TYPE)
+        .map((block) => block[FIELDS.blockText])
+        .filter((text) => typeof text === 'string');
+    return words.length === 0 ? undefined : words.join('\n');
+}

package/dist/adapter/claude-code/probe/transcript-tally.js

@@ -0,0 +1,74 @@
+import { parseJsonObject } from '../../../shared/json.js';
+import { DeniedCallCollector } from './collectors/denied-call-collector.js';
+import { IdentifierCollector } from './collectors/identifier-collector.js';
+import { LineTypeCollector } from './collectors/line-type-collector.js';
+import { SidechainCollector } from './collectors/sidechain-collector.js';
+import { ToolUseCollector } from './collectors/tool-use-collector.js';
+import { TopLevelKeyCollector } from './collectors/top-level-key-collector.js';
+import { UnknownLineTypeKeyCollector } from './collectors/unknown-line-type-key-collector.js';
+/**
+ * Statistics for one group of transcripts (main session or subagents). Composed of collectors: its own, which
+ * measure this group, and the session's, which measure across groups.
+ */
+export class TranscriptTally {
+    #files = 0;
+    #unreadableFiles = 0;
+    #lines = 0;
+    #unparsableLines = 0;
+    #identifiers = new IdentifierCollector();
+    #topLevelKeys = new TopLevelKeyCollector();
+    #lineTypes = new LineTypeCollector();
+    #unknownLineTypeKeys = new UnknownLineTypeKeyCollector();
+    #sidechain = new SidechainCollector();
+    #toolUses = new ToolUseCollector();
+    #deniedCalls = new DeniedCallCollector();
+    #collectors;
+    constructor(sessionCollectors) {
+        this.#collectors = [
+            this.#identifiers,
+            this.#topLevelKeys,
+            this.#lineTypes,
+            this.#unknownLineTypeKeys,
+            this.#sidechain,
+            this.#toolUses,
+            this.#deniedCalls,
+            ...sessionCollectors,
+        ];
+    }
+    recordFile() {
+        this.#files += 1;
+    }
+    recordUnreadableFile() {
+        this.#unreadableFiles += 1;
+    }
+    recordLine(raw) {
+        if (raw.trim() === '')
+            return;
+        this.#lines += 1;
+        const json = parseJsonObject(raw);
+        if (json === undefined)
+            this.#unparsableLines += 1;
+        const line = { raw, json };
+        for (const collector of this.#collectors)
+            collector.collect(line);
+    }
+    toStats() {
+        return {
+            files: this.#files,
+            unreadableFiles: this.#unreadableFiles,
+            lines: this.#lines,
+            unparsableLines: this.#unparsableLines,
+            lineTypes: this.#lineTypes.lineTypes(),
+            unknownLineTypes: this.#lineTypes.unknownLineTypes(),
+            unknownLineTypeKeys: this.#unknownLineTypeKeys.keysByType(),
+            topLevelKeys: this.#topLevelKeys.counts(),
+            sidechain: this.#sidechain.stats(),
+            systemSubtypes: this.#lineTypes.systemSubtypes(),
+            tools: this.#toolUses.tools(),
+            agentToolUses: this.#toolUses.agentToolUses(),
+            deniedCalls: this.#deniedCalls.deniedCalls(),
+            uniqueToolUseIds: this.#identifiers.uniqueToolUseIds(),
+            uniqueUuids: this.#identifiers.uniqueUuids(),
+        };
+    }
+}

package/dist/adapter/claude-code/settings/deny-entries.js

@@ -0,0 +1,65 @@
+import { fileRulePathOf } from '../policy/deny-rules.js';
+import { isJsonObject } from '../../../shared/json.js';
+import { PERMISSIONS } from '../contract/settings.js';
+/**
+ * The tools a path is denied for. `Read` and `Edit` are what a deny rule can name about a file and what this project
+ * already reads back as a policy; `Bash(...)` is a command pattern, not a path, and `init` writes none (test A7).
+ */
+const TOOLS = ['Read', 'Edit'];
+/** The deny entries a pattern becomes, in the order they are written. */
+export function denyEntriesFor(pattern) {
+    return TOOLS.map((tool) => `${tool}(${pattern})`);
+}
+/** Every deny entry a settings object holds, in the order written; empty when it holds no deny list. */
+export function denyEntriesIn(settings) {
+    const permissions = settings[PERMISSIONS.permissions];
+    const deny = isJsonObject(permissions) ? permissions[PERMISSIONS.deny] : undefined;
+    return Array.isArray(deny) ? deny.filter((entry) => typeof entry === 'string') : [];
+}
+/** Of those, the ones that name a file - what a hook reads as a policy, and what R4d copies. */
+export function fileRulesIn(settings) {
+    return denyEntriesIn(settings).filter((entry) => fileRulePathOf(entry) !== undefined);
+}
+/**
+ * The settings with these deny entries added, in order, skipping any that is already there
+ * (`specs/2026-09-16-worth-running-every-day.md` R4c). Every other key, and every rule someone else wrote, stays as it
+ * was: `init` adds, and never edits or removes a rule of its own accord.
+ */
+export function withDenyEntries(settings, entries) {
+    const held = new Set(denyEntriesIn(settings));
+    // Deduplicated against what is there and within what is being added: a rule written twice reads as two rules.
+    const added = [...new Set(entries)].filter((entry) => !held.has(entry));
+    if (added.length === 0)
+        return settings;
+    const permissions = isJsonObject(settings[PERMISSIONS.permissions]) ? { ...settings[PERMISSIONS.permissions] } : {};
+    return {
+        ...settings,
+        [PERMISSIONS.permissions]: { ...permissions, [PERMISSIONS.deny]: [...denyEntriesIn(settings), ...added] },
+    };
+}
+/**
+ * The settings without these deny entries (`specs/2026-09-16-worth-running-every-day.md` R26): an empty deny list is
+ * dropped, and `permissions` left with nothing in it is dropped too, so undoing leaves the file as it was found.
+ */
+export function withoutDenyEntries(settings, entries) {
+    const taking = new Set(entries);
+    const held = denyEntriesIn(settings);
+    const kept = held.filter((entry) => !taking.has(entry));
+    if (kept.length === held.length)
+        return { settings, removed: 0 };
+    const permissions = isJsonObject(settings[PERMISSIONS.permissions]) ? { ...settings[PERMISSIONS.permissions] } : {};
+    if (kept.length > 0) {
+        return { settings: { ...settings, [PERMISSIONS.permissions]: { ...permissions, [PERMISSIONS.deny]: kept } }, removed: held.length - kept.length };
+    }
+    const { [PERMISSIONS.deny]: _dropped, ...rest } = permissions;
+    const { [PERMISSIONS.permissions]: _also, ...outside } = settings;
+    return {
+        settings: Object.keys(rest).length === 0 ? outside : { ...outside, [PERMISSIONS.permissions]: rest },
+        removed: held.length,
+    };
+}
+/** Whether a pattern is already denied for every tool `init` would write it for. */
+export function isDenied(settings, pattern) {
+    const held = new Set(denyEntriesIn(settings));
+    return denyEntriesFor(pattern).every((entry) => held.has(entry));
+}