@astudioplus/compressor 0.1.0

package/dist/adapters/copilot.js

@@ -0,0 +1,418 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { parseAtomManifest, renderMarkedSection } from "../packs/render.js";
+import { copilotHookCommandFrom } from "../paths.js";
+import { readMarkedSection, removeMarkedSection, upsertMarkedSection, } from "./markers.js";
+// Copilot reads .github/copilot-instructions.md for instructions, and Copilot
+// CLI + cloud agent run command hooks from .github/hooks/*.json. Our
+// postToolUse entry replaces tool results via modifiedResult.textResultForLlm
+// — the same input-compression mechanism as the Claude Code PostToolUse hook.
+//
+// Honesty notes baked into status:
+// - hooks run in Copilot CLI and cloud agent ONLY; the VS Code/IDE surface
+//   does not execute these hook files (instructions still apply there)
+// - the installed command is `node "<abs path>/dist/copilot-hook.js" ...` —
+//   an absolute path on THIS machine. The cloud agent's Linux sandbox (and
+//   any teammate's clone of a committed .github/hooks/compressor.json)
+//   cannot run it, so compression is effective only in Copilot CLI on the
+//   installing machine; elsewhere the entry is a dead command that degrades
+//   to a logged fail-open no-op (postToolUse never blocks the agent).
+//   Status must not imply a cloud-agent benefit.
+// - user-scope hooks (<copilotHome>/hooks/, CLI >= 1.0.21; copilotHome is
+//   $COPILOT_HOME when set, else ~/.copilot) load in Copilot CLI only. Global
+//   install therefore plans ONLY the hook config there — instructions have no
+//   user-global mechanism at all (personal instructions are a github.com web
+//   setting), the IDE runs no hook files, and the cloud agent reads only
+//   .github/hooks/ on the default branch.
+const HOOK_SURFACES_NOTE = 'compression effective in Copilot CLI on this machine only — the hook command is an absolute local path (a fail-open no-op for cloud agent and teammates; the IDE runs no hook files)';
+const HOOK_MISSING_NOTE = 'instructions only — compression hook not installed (.github/hooks/compressor.json)';
+const AGENTS_MD_OVERLAP_NOTE = 'NOTE: Copilot also reads AGENTS.md — both installed means duplicated instructions';
+const GLOBAL_HOOK_NOTE = 'machine-wide input compression for Copilot CLI on this machine (instructions are per-repo; IDE runs no hook files; cloud agent reads only .github/hooks on the default branch)';
+const GLOBAL_CROSS_NOTE = 'installed globally (machine-wide hook)';
+/** Our hook config file under .github/hooks/ (any NAME.json is valid). */
+const HOOK_CONFIG_FILE = 'compressor.json';
+/**
+ * postToolUse accepts no matcher, so this command runs after EVERY successful
+ * tool call. Compression is local CPU only; cap well below the 30s default so
+ * a wedged node process cannot stall the agent. Non-zero/timeout is fail-open.
+ */
+const HOOK_TIMEOUT_SEC = 10;
+function instructionsPath(ctx) {
+    return path.join(ctx.projectDir, '.github', 'copilot-instructions.md');
+}
+function hookConfigPath(ctx) {
+    return path.join(ctx.projectDir, '.github', 'hooks', HOOK_CONFIG_FILE);
+}
+/**
+ * The effective $COPILOT_HOME override, or null when unset (whitespace-only
+ * counts as unset). Non-absolute values — including a literal `~`, which Node
+ * never expands — are refused: every scope decision (detect/install/uninstall/
+ * status) routes through this value, and a relative path would anchor the
+ * "machine-wide" hook to whatever directory the command happened to run from
+ * (global-to-project scope leakage; an uninstall from any other cwd could
+ * never find the file again).
+ */
+function copilotHomeOverride() {
+    const env = process.env['COPILOT_HOME'];
+    if (env === undefined || env.trim() === '') {
+        return null;
+    }
+    if (!path.isAbsolute(env)) {
+        throw new Error(`COPILOT_HOME=${JSON.stringify(env)} is not an absolute path — refusing to anchor the machine-wide hook to the current directory (~ is not expanded; set an absolute path or unset it, then re-run)`);
+    }
+    return env;
+}
+/** $COPILOT_HOME when set (Copilot CLI honors it), else ~/.copilot. */
+function copilotHome(ctx) {
+    return copilotHomeOverride() ?? path.join(ctx.homeDir, '.copilot');
+}
+function globalHookConfigPath(ctx) {
+    return path.join(copilotHome(ctx), 'hooks', HOOK_CONFIG_FILE);
+}
+/** Human form of the global config location for status lines. */
+function globalHookConfigDisplay() {
+    return copilotHomeOverride() !== null
+        ? `$COPILOT_HOME/hooks/${HOOK_CONFIG_FILE}`
+        : `~/.copilot/hooks/${HOOK_CONFIG_FILE}`;
+}
+function agentsMdPath(ctx) {
+    return path.join(ctx.projectDir, 'AGENTS.md');
+}
+function isErrnoException(error) {
+    return error instanceof Error && 'code' in error;
+}
+async function readFileOrNull(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+async function dirExists(dirPath) {
+    try {
+        return (await stat(dirPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : null;
+}
+function notTouchingIt(what) {
+    return new Error(`${HOOK_CONFIG_FILE} ${what} — not touching it (fix or remove it, then re-run)`);
+}
+function parseHookConfig(text) {
+    if (text === null) {
+        return { version: 1 };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw notTouchingIt('is not valid JSON');
+    }
+    const record = asRecord(parsed);
+    if (record === null) {
+        throw notTouchingIt('is not valid JSON');
+    }
+    // A non-object "hooks" or non-array "postToolUse" (an easy hand-edit
+    // mistake) would otherwise be coerced to empty by mergeOurHook and written
+    // back as only our entry — silently destroying foreign data. Refuse, same
+    // as invalid JSON. (Foreign events keep whatever shape they have; merge
+    // never rewrites them.)
+    if (record['hooks'] !== undefined) {
+        const hooks = asRecord(record['hooks']);
+        if (hooks === null) {
+            throw notTouchingIt('has a non-object "hooks" value');
+        }
+        if (hooks['postToolUse'] !== undefined && asArray(hooks['postToolUse']) === null) {
+            throw notTouchingIt('has a non-array "hooks.postToolUse" value');
+        }
+    }
+    return { ...record };
+}
+function detectIndent(original) {
+    if (original === null) {
+        return '  ';
+    }
+    return /\n([ \t]+)"/.exec(original)?.[1] ?? '  ';
+}
+function serializeHookConfig(config, original) {
+    return `${JSON.stringify(config, null, detectIndent(original))}\n`;
+}
+function commandBase(command) {
+    return command.replace(/ --mode \S+$/, '');
+}
+/**
+ * Base forms we accept as ours: the current command (copilot-hook.js path
+ * quoted against spaces) and an unquoted variant (legacy tolerance, mirroring
+ * the claude-code predicate).
+ */
+function ourBases(ourCommand) {
+    const base = commandBase(ourCommand);
+    const unquoted = base.replaceAll('"', '');
+    return unquoted === base ? [base] : [base, unquoted];
+}
+function commandIsOurs(command, ourCommand) {
+    if (typeof command !== 'string') {
+        return false;
+    }
+    return (command === ourCommand ||
+        ourBases(ourCommand).some((base) => command === base || command.startsWith(`${base} --mode `)));
+}
+/**
+ * Ownership predicate: exact match on our resolved copilot-hook command in
+ * the entry's bash or powershell field, allowing a different --mode value
+ * (mode switches rewrite the flag; the absolute path identifies us). Generic
+ * substrings like 'dist/copilot-hook.js' are NOT ours.
+ */
+function isOurHookEntry(entry, ourCommand) {
+    const record = asRecord(entry);
+    if (record === null) {
+        return false;
+    }
+    return (commandIsOurs(record['bash'], ourCommand) ||
+        commandIsOurs(record['powershell'], ourCommand));
+}
+function hookEntryFor(command) {
+    // both platform keys per the reference docs; node invocation is identical
+    return {
+        type: 'command',
+        bash: command,
+        powershell: command,
+        timeoutSec: HOOK_TIMEOUT_SEC,
+    };
+}
+/** Replace our postToolUse entry (or append it), preserving foreign entries and events. */
+function mergeOurHook(config, command) {
+    const hooks = { ...(asRecord(config['hooks']) ?? {}) };
+    const post = asArray(hooks['postToolUse']) ?? [];
+    const ourEntry = hookEntryFor(command);
+    const next = [];
+    let replaced = false;
+    for (const entry of post) {
+        if (isOurHookEntry(entry, command)) {
+            if (!replaced) {
+                next.push(ourEntry);
+                replaced = true;
+            }
+        }
+        else {
+            next.push(entry);
+        }
+    }
+    if (!replaced) {
+        next.push(ourEntry);
+    }
+    hooks['postToolUse'] = next;
+    config['hooks'] = hooks;
+    if (config['version'] === undefined) {
+        config['version'] = 1;
+    }
+}
+/** Remove only our entries. Returns true when something was removed. */
+function stripOurHook(config, command) {
+    const hooks = asRecord(config['hooks']);
+    const post = asArray(hooks?.['postToolUse']);
+    if (hooks === null || post === null) {
+        return false;
+    }
+    const kept = post.filter((entry) => !isOurHookEntry(entry, command));
+    if (kept.length === post.length) {
+        return false;
+    }
+    const next = { ...hooks };
+    if (kept.length === 0) {
+        delete next['postToolUse'];
+    }
+    else {
+        next['postToolUse'] = kept;
+    }
+    if (Object.keys(next).length === 0) {
+        delete config['hooks'];
+    }
+    else {
+        config['hooks'] = next;
+    }
+    return true;
+}
+/** Nothing left but the schema version ⇒ the file carries no information. */
+function onlyVersionLeft(config) {
+    return Object.keys(config).every((key) => key === 'version');
+}
+/**
+ * Plan merging our entry into the hook config at `filePath` (project or
+ * global scope — the merge/ownership/foreign-preservation rules are
+ * identical; only the path differs).
+ */
+async function planHookConfigInstall(filePath, command) {
+    const before = await readFileOrNull(filePath);
+    const config = parseHookConfig(before);
+    mergeOurHook(config, command);
+    return { path: filePath, before, after: serializeHookConfig(config, before) };
+}
+/**
+ * Plan stripping our entry from the hook config at `filePath`. Returns null
+ * when there is nothing of ours to remove. compressor.json is our namespaced
+ * file: once only the version stub remains it is safe to delete; foreign
+ * entries/events keep it alive.
+ */
+async function planHookConfigUninstall(filePath, ourCommand) {
+    const before = await readFileOrNull(filePath);
+    if (before === null) {
+        return null;
+    }
+    const config = parseHookConfig(before);
+    if (!stripOurHook(config, ourCommand)) {
+        return null;
+    }
+    const after = onlyVersionLeft(config)
+        ? null
+        : serializeHookConfig(config, before);
+    return { path: filePath, before, after };
+}
+async function inspectHookAt(filePath, ourCommand) {
+    const text = await readFileOrNull(filePath);
+    if (text === null) {
+        return { present: false, mode: null };
+    }
+    let config = null;
+    try {
+        config = parseHookConfig(text);
+    }
+    catch {
+        config = null; // status never throws on a broken file
+    }
+    const post = asArray(asRecord(config?.['hooks'])?.['postToolUse']);
+    const ours = post?.find((entry) => isOurHookEntry(entry, ourCommand));
+    if (ours === undefined) {
+        return { present: false, mode: null };
+    }
+    const bash = asRecord(ours)?.['bash'];
+    const flag = typeof bash === 'string' ? / --mode (\S+)$/.exec(bash)?.[1] : undefined;
+    return {
+        present: true,
+        mode: flag === 'optimized' || flag === 'slim' ? flag : null,
+    };
+}
+export const copilotAdapter = {
+    name: 'copilot',
+    async detect(ctx) {
+        if (ctx.global) {
+            return dirExists(copilotHome(ctx));
+        }
+        return dirExists(path.join(ctx.projectDir, '.github'));
+    },
+    async install(mode, ctx) {
+        const command = copilotHookCommandFrom(ctx.hookCommand, mode);
+        if (ctx.global) {
+            // user-scope hooks load in Copilot CLI only; instructions have no
+            // user-global mechanism, so global plans ONLY the hook config — never
+            // an instructions change.
+            const change = await planHookConfigInstall(globalHookConfigPath(ctx), command);
+            return change.before === change.after ? [] : [change];
+        }
+        const changes = [];
+        const file = instructionsPath(ctx);
+        const before = await readFileOrNull(file);
+        const after = upsertMarkedSection(before, renderMarkedSection(mode, 'copilot').body);
+        changes.push({ path: file, before, after });
+        changes.push(await planHookConfigInstall(hookConfigPath(ctx), command));
+        return changes.filter((change) => change.before !== change.after);
+    },
+    async uninstall(ctx) {
+        const ourCommand = copilotHookCommandFrom(ctx.hookCommand);
+        if (ctx.global) {
+            const change = await planHookConfigUninstall(globalHookConfigPath(ctx), ourCommand);
+            return change === null ? [] : [change];
+        }
+        const changes = [];
+        const file = instructionsPath(ctx);
+        const before = await readFileOrNull(file);
+        if (before !== null && readMarkedSection(before) !== null) {
+            // Never delete the file: whether WE created it is not derivable from
+            // disk (a user-created empty file that received our section is
+            // byte-identical to one we created), so err KEEP — worst case an empty
+            // file remains. Matches the cursor .cursorrules precedent.
+            changes.push({ path: file, before, after: removeMarkedSection(before) });
+        }
+        const hookChange = await planHookConfigUninstall(hookConfigPath(ctx), ourCommand);
+        if (hookChange !== null) {
+            changes.push(hookChange);
+        }
+        return changes;
+    },
+    async status(ctx) {
+        const ourCommand = copilotHookCommandFrom(ctx.hookCommand);
+        const globalHook = await inspectHookAt(globalHookConfigPath(ctx), ourCommand);
+        if (ctx.global) {
+            if (!globalHook.present) {
+                return { agent: 'copilot', installed: false, detail: 'not installed' };
+            }
+            return {
+                agent: 'copilot',
+                installed: true,
+                ...(globalHook.mode !== null ? { mode: globalHook.mode } : {}),
+                detail: `${globalHookConfigDisplay()} (global) — ${GLOBAL_HOOK_NOTE}`,
+            };
+        }
+        const body = await readFileOrNull(instructionsPath(ctx));
+        const section = body === null ? null : readMarkedSection(body);
+        const hook = await inspectHookAt(hookConfigPath(ctx), ourCommand);
+        if (section === null && !hook.present) {
+            if (globalHook.present) {
+                // scope-faithful: nothing at project level, but the machine-wide
+                // hook still compresses Copilot CLI input here (claude-code's
+                // cross-scope note pattern)
+                return {
+                    agent: 'copilot',
+                    installed: true,
+                    ...(globalHook.mode !== null ? { mode: globalHook.mode } : {}),
+                    detail: `not installed (project); ${GLOBAL_CROSS_NOTE}`,
+                };
+            }
+            return { agent: 'copilot', installed: false, detail: 'not installed' };
+        }
+        const mode = (section === null ? undefined : parseAtomManifest(section)?.mode) ??
+            hook.mode ??
+            globalHook.mode ??
+            undefined;
+        let detail;
+        if (section !== null && hook.present) {
+            detail = `.github/copilot-instructions.md section + .github/hooks/${HOOK_CONFIG_FILE} (project) — instructions + input compression (Copilot hooks); ${HOOK_SURFACES_NOTE}`;
+        }
+        else if (section !== null) {
+            detail = `.github/copilot-instructions.md section (project) — ${HOOK_MISSING_NOTE}`;
+        }
+        else {
+            detail = `.github/hooks/${HOOK_CONFIG_FILE} (project) — input compression only, instructions not installed; ${HOOK_SURFACES_NOTE}`;
+        }
+        if (section !== null) {
+            const agentsMd = await readFileOrNull(agentsMdPath(ctx));
+            if (agentsMd !== null && readMarkedSection(agentsMd) !== null) {
+                detail += `; ${AGENTS_MD_OVERLAP_NOTE}`;
+            }
+        }
+        if (globalHook.present) {
+            detail += `; also ${GLOBAL_CROSS_NOTE}`;
+        }
+        return {
+            agent: 'copilot',
+            installed: true,
+            ...(mode !== undefined ? { mode } : {}),
+            detail,
+        };
+    },
+};

package/dist/adapters/cursor.d.ts

@@ -0,0 +1,2 @@
+import type { Adapter } from './types.ts';
+export declare const cursorAdapter: Adapter;

package/dist/adapters/cursor.js

@@ -0,0 +1,149 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { parseAtomManifest, renderCursorRules, renderMarkedSection, } from "../packs/render.js";
+import { readMarkedSection, removeMarkedSection, upsertMarkedSection, } from "./markers.js";
+// Cursor's rules system reads .cursor/rules/*.mdc — a plain .md file there is
+// silently ignored, and frontmatter is mandatory (renderCursorRules emits
+// description + alwaysApply: true; with alwaysApply: true the other fields are
+// ignored by Cursor, but description doubles as our mode manifest). Cursor
+// ships a stable hooks system (sessionStart, preToolUse/postToolUse,
+// beforeReadFile, ...), but postToolUse can replace output for MCP tools only
+// (updated_mcp_tool_output) and beforeReadFile is permission-only, so
+// compressor-style rewriting of built-in Read/Shell output is not currently
+// possible — only the instruction half of compressor applies.
+const ASYMMETRY_NOTE = 'instructions only — Cursor hooks cannot rewrite built-in tool output (postToolUse replaces MCP output only)';
+const MODIFIED_NOTE = 'locally modified — install will overwrite';
+const AGENTS_MD_OVERLAP_NOTE = 'NOTE: Cursor also reads AGENTS.md — both installed means duplicated instructions';
+function mdcPath(ctx) {
+    return path.join(ctx.projectDir, '.cursor', 'rules', 'compressor.mdc');
+}
+// Deprecated (dropped from Cursor's docs) but still read for back-compat:
+// if the user already drives Cursor through it we upsert a marked section
+// there too. Never created by us.
+function legacyRulesPath(ctx) {
+    return path.join(ctx.projectDir, '.cursorrules');
+}
+function agentsMdPath(ctx) {
+    return path.join(ctx.projectDir, 'AGENTS.md');
+}
+function isErrnoException(error) {
+    return error instanceof Error && 'code' in error;
+}
+async function readFileOrNull(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+async function dirExists(dirPath) {
+    try {
+        return (await stat(dirPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export const cursorAdapter = {
+    name: 'cursor',
+    async detect(ctx) {
+        return ((await dirExists(path.join(ctx.projectDir, '.cursor'))) ||
+            (await fileExists(legacyRulesPath(ctx))));
+    },
+    async install(mode, ctx) {
+        if (ctx.global) {
+            throw new Error('cursor: Cursor rules are per-project; use project scope');
+        }
+        const changes = [];
+        // compressor-owned file: overwrite wholesale, no markers needed
+        const mdcFile = mdcPath(ctx);
+        const mdcBefore = await readFileOrNull(mdcFile);
+        const mdcAfter = renderCursorRules(mode).body;
+        if (mdcAfter !== mdcBefore) {
+            changes.push({ path: mdcFile, before: mdcBefore, after: mdcAfter });
+        }
+        const legacyFile = legacyRulesPath(ctx);
+        const legacyBefore = await readFileOrNull(legacyFile);
+        if (legacyBefore !== null) {
+            const legacyAfter = upsertMarkedSection(legacyBefore, renderMarkedSection(mode, 'cursor').body);
+            if (legacyAfter !== legacyBefore) {
+                changes.push({ path: legacyFile, before: legacyBefore, after: legacyAfter });
+            }
+        }
+        return changes;
+    },
+    async uninstall(ctx) {
+        if (ctx.global) {
+            // install refuses global scope, so nothing of ours can exist there
+            return [];
+        }
+        const changes = [];
+        const mdcFile = mdcPath(ctx);
+        const mdcBefore = await readFileOrNull(mdcFile);
+        if (mdcBefore !== null) {
+            changes.push({ path: mdcFile, before: mdcBefore, after: null });
+        }
+        const legacyFile = legacyRulesPath(ctx);
+        const legacyBefore = await readFileOrNull(legacyFile);
+        if (legacyBefore !== null && readMarkedSection(legacyBefore) !== null) {
+            // never delete .cursorrules — we never create it, only sectioned it
+            changes.push({
+                path: legacyFile,
+                before: legacyBefore,
+                after: removeMarkedSection(legacyBefore),
+            });
+        }
+        return changes;
+    },
+    async status(ctx) {
+        const mdcBody = await readFileOrNull(mdcPath(ctx));
+        const legacyBody = await readFileOrNull(legacyRulesPath(ctx));
+        const legacySection = legacyBody === null ? null : readMarkedSection(legacyBody);
+        if (mdcBody === null && legacySection === null) {
+            return { agent: 'cursor', installed: false, detail: 'not installed' };
+        }
+        const mdcMode = mdcBody === null ? undefined : parseAtomManifest(mdcBody)?.mode;
+        let mode = mdcMode;
+        if (mode === undefined && legacySection !== null) {
+            mode = parseAtomManifest(legacySection)?.mode;
+        }
+        // Hand edits to the compressor-owned .mdc are otherwise invisible: install
+        // overwrites wholesale and uninstall deletes unconditionally, so surface
+        // any drift from what install would write (including a broken manifest).
+        const mdcModified = mdcBody !== null &&
+            (mdcMode === undefined || mdcBody !== renderCursorRules(mdcMode).body);
+        const parts = [];
+        if (mdcBody !== null) {
+            parts.push('.cursor/rules/compressor.mdc');
+        }
+        if (legacySection !== null) {
+            parts.push('legacy .cursorrules section');
+        }
+        let detail = `${parts.join(' + ')} (project) — ${ASYMMETRY_NOTE}`;
+        if (mdcModified) {
+            detail += `; ${MODIFIED_NOTE}`;
+        }
+        const agentsMd = await readFileOrNull(agentsMdPath(ctx));
+        if (agentsMd !== null && readMarkedSection(agentsMd) !== null) {
+            detail += `; ${AGENTS_MD_OVERLAP_NOTE}`;
+        }
+        return {
+            agent: 'cursor',
+            installed: true,
+            ...(mode !== undefined ? { mode } : {}),
+            detail,
+        };
+    },
+};

package/dist/adapters/index.d.ts

@@ -0,0 +1,11 @@
+import type { AgentName } from '../packs/types.ts';
+import type { Adapter } from './types.ts';
+export declare const adapters: Adapter[];
+export declare function getAdapter(name: AgentName): Adapter | undefined;
+export { claudeCodeAdapter } from './claude-code.ts';
+export { copilotAdapter } from './copilot.ts';
+export { cursorAdapter } from './cursor.ts';
+export { agentsMdAdapter } from './agents-md.ts';
+export { applyChanges, renderChanges } from './apply.ts';
+export { upsertMarkedSection, removeMarkedSection, readMarkedSection, } from './markers.ts';
+export type { Adapter, AdapterContext, AdapterStatus, FileChange, ModeArg, } from './types.ts';

package/dist/adapters/index.js

@@ -0,0 +1,19 @@
+import { claudeCodeAdapter } from "./claude-code.js";
+import { copilotAdapter } from "./copilot.js";
+import { cursorAdapter } from "./cursor.js";
+import { agentsMdAdapter } from "./agents-md.js";
+export const adapters = [
+    claudeCodeAdapter,
+    copilotAdapter,
+    cursorAdapter,
+    agentsMdAdapter,
+];
+export function getAdapter(name) {
+    return adapters.find((adapter) => adapter.name === name);
+}
+export { claudeCodeAdapter } from "./claude-code.js";
+export { copilotAdapter } from "./copilot.js";
+export { cursorAdapter } from "./cursor.js";
+export { agentsMdAdapter } from "./agents-md.js";
+export { applyChanges, renderChanges } from "./apply.js";
+export { upsertMarkedSection, removeMarkedSection, readMarkedSection, } from "./markers.js";

package/dist/adapters/markers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Replace the compressor section in place if present; else append with exactly
+ * one blank line of separation. Bytes outside the markers are never modified.
+ */
+export declare function upsertMarkedSection(existing: string | null, section: string): string;
+export declare function removeMarkedSection(existing: string): string;
+export declare function readMarkedSection(existing: string): string | null;