@kisev/agentomatic 11.0.0-dev.46.gfbe1e4c6992e

package/dist/package-metadata.d.ts

@@ -0,0 +1,4 @@
+export declare function readPackageVersion(): string | null;
+export declare function requirePackageVersion(): string;
+export declare function requireSkillsInstallerVersion(): string;
+export declare function skillsInstallerSpec(): string;

package/dist/package-metadata.js

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const packageJson = resolve(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+let cachedMetadata;
+function readPackageMetadata() {
+    if (cachedMetadata !== undefined)
+        return cachedMetadata;
+    try {
+        const value = JSON.parse(readFileSync(packageJson, "utf8"));
+        cachedMetadata =
+            value && typeof value === "object" && !Array.isArray(value)
+                ? value
+                : null;
+    }
+    catch {
+        cachedMetadata = null;
+    }
+    return cachedMetadata;
+}
+function readString(name) {
+    const value = readPackageMetadata()?.[name];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+export function readPackageVersion() {
+    return readString("version");
+}
+export function requirePackageVersion() {
+    const version = readPackageVersion();
+    if (!version)
+        throw new Error("Package version is unavailable");
+    return version;
+}
+export function requireSkillsInstallerVersion() {
+    const version = readString("skillsInstallerVersion");
+    if (!version)
+        throw new Error("Skills installer version is unavailable");
+    return version;
+}
+export function skillsInstallerSpec() {
+    return `skills@${requireSkillsInstallerVersion()}`;
+}

package/dist/plugins/memomatic.d.ts

@@ -0,0 +1,76 @@
+export type MemomaticOptions = {
+    enabled?: boolean;
+    bootstrapBudgetChars?: number;
+};
+export declare function memomatic(options?: MemomaticOptions): Promise<{
+    "experimental.chat.system.transform"?: undefined;
+    tool?: undefined;
+} | {
+    "experimental.chat.system.transform": (_input: unknown, output: {
+        system: string[];
+    }) => Promise<void>;
+    tool: {
+        memory_forget: {
+            description: string;
+            args: {
+                file: import("zod").ZodString;
+                line: import("zod").ZodNumber;
+            };
+            execute(args: {
+                file: string;
+                line: number;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+        memory_get: {
+            description: string;
+            args: {
+                file: import("zod").ZodString;
+                line: import("zod").ZodOptional<import("zod").ZodNumber>;
+            };
+            execute(args: {
+                file: string;
+                line?: number | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+        memory_search: {
+            description: string;
+            args: {
+                query: import("zod").ZodString;
+            };
+            execute(args: {
+                query: string;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+        memory_write: {
+            description: string;
+            args: {
+                text: import("zod").ZodString;
+                target: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    curated: "curated";
+                    episodic: "episodic";
+                    user: "user";
+                }>>;
+                origin: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    agent: "agent";
+                    user: "user";
+                }>>;
+                key: import("zod").ZodOptional<import("zod").ZodString>;
+                project: import("zod").ZodOptional<import("zod").ZodString>;
+                importance: import("zod").ZodOptional<import("zod").ZodNumber>;
+                trigger: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                pinned: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            };
+            execute(args: {
+                text: string;
+                target?: "curated" | "episodic" | "user" | undefined;
+                origin?: "agent" | "user" | undefined;
+                key?: string | undefined;
+                project?: string | undefined;
+                importance?: number | undefined;
+                trigger?: string[] | undefined;
+                pinned?: boolean | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+    };
+}>;
+export default memomatic;

package/dist/plugins/memomatic.js

@@ -0,0 +1,101 @@
+import { tool } from "@opencode-ai/plugin";
+import { forgetEntry, getEntry, openMemomatic, searchMemory, writeEntry, } from "@kisev/memomatic";
+const DEFAULT_BOOTSTRAP_BUDGET = 4_000;
+async function withContext(work) {
+    const context = await openMemomatic();
+    try {
+        return JSON.stringify(await work(context));
+    }
+    finally {
+        context.store.close();
+    }
+}
+export async function memomatic(options = {}) {
+    if (options.enabled === false)
+        return {};
+    const budget = options.bootstrapBudgetChars ?? DEFAULT_BOOTSTRAP_BUDGET;
+    const memorySearch = tool({
+        args: { query: tool.schema.string() },
+        description: "Search personal long-term memory for durable decisions, discoveries, failed attempts, and session outcomes.",
+        async execute(args) {
+            return withContext((context) => searchMemory(context, args.query));
+        },
+    });
+    const memoryGet = tool({
+        args: {
+            file: tool.schema.string(),
+            line: tool.schema.number().optional(),
+        },
+        description: "Read a memomatic memory file fully or one line. Fetching a line marks that entry as useful.",
+        async execute(args) {
+            return withContext((context) => getEntry(context, args.file, args.line));
+        },
+    });
+    const memoryWrite = tool({
+        args: {
+            text: tool.schema.string(),
+            target: tool.schema.enum(["episodic", "curated", "user"]).optional(),
+            origin: tool.schema.enum(["user", "agent"]).optional(),
+            key: tool.schema.string().optional(),
+            project: tool.schema.string().optional(),
+            importance: tool.schema.number().min(1).max(10).optional(),
+            trigger: tool.schema.array(tool.schema.string()).optional(),
+            pinned: tool.schema.boolean().optional(),
+        },
+        description: "Save a durable memory entry: standing decisions with rationale, discoveries, failed attempts with rejection reasons, session outcomes, action-sensitive boundaries. Respect MEMORY_RULES.md; never-save topics are rejected.",
+        async execute(args) {
+            return withContext((context) => writeEntry(context, {
+                importance: args.importance,
+                key: args.key,
+                origin: args.origin,
+                pinned: args.pinned,
+                project: args.project,
+                target: args.target,
+                text: args.text,
+                trigger: args.trigger,
+            }));
+        },
+    });
+    const memoryForget = tool({
+        args: { file: tool.schema.string(), line: tool.schema.number() },
+        description: "Remove one entry line from a memomatic memory file (explicit deletion only).",
+        async execute(args) {
+            return withContext((context) => forgetEntry(context, args));
+        },
+    });
+    return {
+        "experimental.chat.system.transform": async (_input, output) => {
+            try {
+                const context = await openMemomatic();
+                try {
+                    const blocks = [];
+                    for (const file of [context.paths.memoryFile, context.paths.userFile]) {
+                        const content = await import("node:fs/promises")
+                            .then((fs) => fs.readFile(file, "utf8"))
+                            .catch(() => undefined);
+                        if (content === undefined || !content.trim())
+                            continue;
+                        const name = file.slice(file.lastIndexOf("/") + 1);
+                        blocks.push(`# Memomatic ${name}\n\n${content.trim().slice(0, budget)}`);
+                    }
+                    if (!blocks.length)
+                        return;
+                    output.system.push(`${blocks.join("\n\n")}\n\nUse memory_search for episodic details and memory_write to save durable outcomes. Never re-save content that is already present in this memory.`);
+                }
+                finally {
+                    context.store.close();
+                }
+            }
+            catch {
+                // Memory bootstrap must never break the session.
+            }
+        },
+        tool: {
+            memory_forget: memoryForget,
+            memory_get: memoryGet,
+            memory_search: memorySearch,
+            memory_write: memoryWrite,
+        },
+    };
+}
+export default memomatic;

package/dist/plugins/rtk.d.ts

@@ -0,0 +1,41 @@
+type HookInput = {
+    tool: string;
+    args?: {
+        command?: unknown;
+    };
+};
+type HookOutput = {
+    output?: unknown;
+};
+export type RtkMethod = "compressed-rtk" | "truncated-head-tail" | "rtk-unavailable" | "ineligible" | "below-threshold";
+export type RtkStats = {
+    schema_version: 1;
+    counters: Record<RtkMethod, number>;
+    chars_original: number;
+    chars_final: number;
+    recent: Array<{
+        at: string;
+        method: RtkMethod;
+        original: number;
+        final: number;
+    }>;
+    updated_at: string;
+};
+export type RtkOptions = {
+    enabled?: boolean;
+    bin?: string;
+    threshold?: number;
+    run?: (filter: string, input: string) => Promise<string | undefined>;
+    statsPath?: string | null;
+};
+export declare function emptyRtkStats(): RtkStats;
+export declare function rtkStatsPath(home?: string): string;
+export declare function rtkCharsSaved(stats: RtkStats): number;
+export declare function rtkTokensSavedEstimate(stats: RtkStats): number;
+export declare function readRtkStats(path?: string): Promise<RtkStats | undefined>;
+export declare function rtk(options?: RtkOptions): Promise<{
+    "tool.execute.after"?: undefined;
+} | {
+    "tool.execute.after": (input: HookInput, output: HookOutput) => Promise<void>;
+}>;
+export default rtk;

package/dist/plugins/rtk.js

@@ -0,0 +1,177 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { stateRoot, withStateLock } from "../runtime/state.js";
+import { writeAtomic } from "../lifecycle.js";
+const THRESHOLD = 8_000;
+const FILTERS = [
+    { prefix: ["git", "log"], filter: "git-log" },
+    { prefix: ["git", "diff"], filter: "git-diff" },
+    { prefix: ["git", "status"], filter: "git-status" },
+    { prefix: ["rg"], filter: "grep" },
+    { prefix: ["grep"], filter: "grep" },
+    { prefix: ["pytest"], filter: "pytest" },
+    { prefix: ["tsc"], filter: "tsc" },
+];
+const RECENT_EVENTS_CAP = 20;
+const CHARS_PER_TOKEN = 4;
+export function emptyRtkStats() {
+    return {
+        schema_version: 1,
+        counters: {
+            "compressed-rtk": 0,
+            "truncated-head-tail": 0,
+            "rtk-unavailable": 0,
+            ineligible: 0,
+            "below-threshold": 0,
+        },
+        chars_original: 0,
+        chars_final: 0,
+        recent: [],
+        updated_at: "",
+    };
+}
+export function rtkStatsPath(home = homedir()) {
+    return join(stateRoot("rtk", home), "stats.json");
+}
+export function rtkCharsSaved(stats) {
+    return Math.max(0, stats.chars_original - stats.chars_final);
+}
+export function rtkTokensSavedEstimate(stats) {
+    return Math.ceil(rtkCharsSaved(stats) / CHARS_PER_TOKEN);
+}
+export async function readRtkStats(path = rtkStatsPath()) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const value = JSON.parse(raw);
+        if (value.schema_version !== 1 ||
+            !value.counters ||
+            typeof value.counters !== "object" ||
+            Array.isArray(value.counters))
+            return undefined;
+        const base = emptyRtkStats();
+        for (const method of Object.keys(base.counters)) {
+            const counter = value.counters[method];
+            if (Number.isSafeInteger(counter) && counter >= 0)
+                base.counters[method] = counter;
+        }
+        return {
+            ...base,
+            chars_original: Number.isSafeInteger(value.chars_original) ? value.chars_original : 0,
+            chars_final: Number.isSafeInteger(value.chars_final) ? value.chars_final : 0,
+            recent: Array.isArray(value.recent)
+                ? value.recent.filter((item) => Boolean(item) &&
+                    typeof item === "object" &&
+                    typeof item.at === "string" &&
+                    typeof item.method === "string" &&
+                    item.method in base.counters &&
+                    typeof item.original === "number" &&
+                    typeof item.final === "number")
+                : [],
+            updated_at: typeof value.updated_at === "string" ? value.updated_at : "",
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function recordStats(path, method, original, final) {
+    const boundary = dirname(path);
+    await withStateLock(boundary, async () => {
+        const current = (await readRtkStats(path)) ?? emptyRtkStats();
+        current.counters[method] += 1;
+        if (method !== "below-threshold") {
+            current.chars_original += original;
+            current.chars_final += final;
+        }
+        current.recent = [
+            ...current.recent.filter((item) => item.at !== ""),
+            { at: new Date().toISOString(), method, original, final },
+        ].slice(-RECENT_EVENTS_CAP);
+        current.updated_at = new Date().toISOString();
+        await writeAtomic(path, Buffer.from(`${JSON.stringify(current)}\n`), 0o600);
+    });
+}
+function filter(command) {
+    if (/[|;$&\n()`]/.test(command))
+        return undefined;
+    if (/\b(--json|--format(?:=|\s)|diagnos|security|deploy|migrat|delete|remove)\b/i.test(command))
+        return undefined;
+    const values = command.trim().split(/\s+/);
+    return FILTERS.find((item) => item.prefix.every((part, index) => values[index] === part))?.filter;
+}
+function truncate(value) {
+    const points = Array.from(value);
+    const size = 3_200;
+    return points.length <= size * 2
+        ? value
+        : `${points.slice(0, size).join("")}\n…\n${points.slice(-size).join("")}`;
+}
+function external(binary, selected, input) {
+    return new Promise((done) => {
+        const child = spawn(binary, ["pipe", "--filter", selected], {
+            stdio: ["pipe", "pipe", "ignore"],
+            timeout: 5_000,
+        });
+        let output = "";
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            output += chunk;
+        });
+        child.once("error", () => done(undefined));
+        child.once("close", (code) => done(code === 0 ? output : undefined));
+        child.stdin.end(input, "utf8");
+    });
+}
+export async function rtk(options = {}) {
+    if (options.enabled === false)
+        return {};
+    const run = options.run ??
+        ((selected, input) => external(options.bin ?? "rtk", selected, input));
+    const statsPath = options.statsPath === null ? undefined : (options.statsPath ?? rtkStatsPath());
+    return {
+        "tool.execute.after": async (input, output) => {
+            try {
+                if (input.tool === "edit" &&
+                    typeof output.output === "string" &&
+                    /oldString (not found|found multiple times|and newString must be different)/i.test(output.output))
+                    output.output = `${output.output}\nSTOP. Read the file before retrying Edit.`;
+                if (input.tool !== "bash" ||
+                    typeof output.output !== "string" ||
+                    output.output.length < (options.threshold ?? THRESHOLD)) {
+                    if (input.tool === "bash" && typeof output.output === "string" && statsPath)
+                        await recordStats(statsPath, "below-threshold", output.output.length, output.output.length);
+                    return;
+                }
+                const selected = typeof input.args?.command === "string" ? filter(input.args.command) : undefined;
+                const compressed = selected ? await run(selected, output.output) : undefined;
+                const result = compressed && compressed.length < output.output.length
+                    ? compressed
+                    : truncate(output.output);
+                const originalSize = output.output.length;
+                output.output = `${result}\n[rtk: compressed method=${result === compressed ? `rtk/${selected}` : "head+tail"}; sizes=${originalSize}->${result.length}; evidence_complete=false; loss=possible]`;
+                if (statsPath) {
+                    const method = result === compressed
+                        ? "compressed-rtk"
+                        : selected === undefined
+                            ? "ineligible"
+                            : compressed === undefined
+                                ? "rtk-unavailable"
+                                : "truncated-head-tail";
+                    await recordStats(statsPath, method, originalSize, result.length);
+                }
+            }
+            catch {
+                /* RTK is fail-open: preserve original tool output on plugin failure. */
+            }
+        },
+    };
+}
+export default rtk;

package/dist/plugins/rules-injector.d.ts

@@ -0,0 +1,22 @@
+export type RulesInjectorOptions = {
+    budget?: number;
+    cwd?: string;
+    enabled?: boolean;
+};
+export declare function rulesInjector(options?: RulesInjectorOptions): Promise<{
+    "tool.execute.after"?: undefined;
+    event?: undefined;
+    "experimental.chat.system.transform"?: undefined;
+} | {
+    "tool.execute.after": (input: unknown, result: unknown) => Promise<void>;
+    event: ({ event, }: {
+        event?: {
+            type?: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+    "experimental.chat.system.transform": (input: unknown, result: {
+        system?: unknown[];
+    }) => Promise<void>;
+}>;
+export default rulesInjector;

package/dist/plugins/rules-injector.js

@@ -0,0 +1,131 @@
+import { lstat, readFile, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+const NAME = "AGENTS.md";
+function sessionID(value) {
+    const item = value;
+    for (const key of ["sessionID", "sessionId", "session_id"])
+        if (typeof item?.[key] === "string" && item[key])
+            return item[key];
+    return undefined;
+}
+function pathOf(input, output) {
+    for (const value of [input, output]) {
+        const args = value?.args;
+        for (const key of ["filePath", "file_path", "path"])
+            if (typeof args?.[key] === "string")
+                return args[key];
+    }
+    return undefined;
+}
+function output(value, text) {
+    const item = value;
+    if (typeof item?.output === "string")
+        item.output = `${item.output}\n${text}`;
+}
+function marker(rule) {
+    return `[rules-injector source=${rule.path} revision=${rule.revision}]`;
+}
+function block(rule) {
+    return `${marker(rule)}\n${rule.content}\n[/rules-injector source=${rule.path}]`;
+}
+export async function rulesInjector(options = {}) {
+    if (options.enabled === false)
+        return {};
+    const budget = options.budget ?? 12_000;
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const global = resolve(process.env.XDG_CONFIG_HOME ?? resolve(homedir(), ".config"), "opencode");
+    const sessions = new Map();
+    const state = (identifier) => {
+        let item = sessions.get(identifier);
+        if (!item) {
+            item = { loaded: new Map(), injected: new Set(), used: 0, replay: false };
+            sessions.set(identifier, item);
+        }
+        return item;
+    };
+    const inject = async (input, result) => {
+        const call = input;
+        if (call?.tool !== "read" && call?.tool !== "edit")
+            return;
+        const identifier = sessionID(input);
+        const target = pathOf(input, result);
+        if (!identifier || !target)
+            return;
+        try {
+            const native = typeof call?.directory === "string" ? call.directory : cwd;
+            const paths = [];
+            let current = dirname(resolve(native, target));
+            while (true) {
+                const candidate = resolve(current, NAME);
+                try {
+                    const info = await lstat(candidate);
+                    if (info.isFile() &&
+                        candidate !== resolve(native, NAME) &&
+                        candidate !== resolve(global, NAME))
+                        paths.push(await realpath(candidate));
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+                const parent = dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            const currentState = state(identifier);
+            const additions = [];
+            for (const path of paths.reverse()) {
+                if (currentState.injected.has(path))
+                    continue;
+                try {
+                    const info = await lstat(path);
+                    if (!info.isFile())
+                        continue;
+                    const rule = {
+                        path,
+                        revision: `${Math.trunc(info.mtimeMs)}:${info.size}`,
+                        content: await readFile(path, "utf8"),
+                    };
+                    const text = block(rule);
+                    if (currentState.used + text.length > budget) {
+                        additions.push(`[rules-injector warning] context budget exhausted; skipped ${path}`);
+                        continue;
+                    }
+                    currentState.loaded.set(path, rule);
+                    currentState.injected.add(path);
+                    currentState.used += text.length;
+                    additions.push(text);
+                }
+                catch (error) {
+                    additions.push(`[rules-injector warning] cannot read ${path}: ${String(error)}`);
+                }
+            }
+            if (additions.length)
+                output(result, additions.join("\n\n"));
+        }
+        catch (error) {
+            output(result, `[rules-injector warning] cannot read AGENTS.md: ${String(error)}`);
+        }
+    };
+    return {
+        "tool.execute.after": inject,
+        event: async ({ event, }) => {
+            if (event?.type?.includes("compaction")) {
+                const identifier = sessionID(event.properties);
+                if (identifier)
+                    state(identifier).replay = true;
+            }
+        },
+        "experimental.chat.system.transform": async (input, result) => {
+            const identifier = sessionID(input);
+            if (!identifier || !state(identifier).replay || !Array.isArray(result.system))
+                return;
+            for (const rule of state(identifier).loaded.values())
+                result.system.push(block(rule));
+            state(identifier).replay = false;
+        },
+    };
+}
+export default rulesInjector;

package/dist/plugins/zed-bell.d.ts

@@ -0,0 +1,13 @@
+export type ZedBellOptions = {
+    enabled?: boolean;
+};
+export declare function zedBell(options?: ZedBellOptions): Promise<{
+    event?: undefined;
+} | {
+    event: ({ event }: {
+        event: {
+            type?: string;
+        };
+    }) => Promise<void>;
+}>;
+export default zedBell;

package/dist/plugins/zed-bell.js

@@ -0,0 +1,14 @@
+export async function zedBell(options = {}) {
+    if (!options.enabled)
+        return {};
+    return {
+        event: async ({ event }) => {
+            if (event.type !== "session.idle" && event.type !== "permission.asked")
+                return;
+            const acp = process.env.OPENCODE_CLIENT === "acp" || process.argv.includes("acp");
+            if (!acp)
+                process.stdout.write("\x07");
+        },
+    };
+}
+export default zedBell;

package/dist/reconcile.d.ts

@@ -0,0 +1,47 @@
+import { LifecycleError, type SupersededPlan, type Scope, type TransactionOptions } from "./lifecycle.js";
+export type ReconcileStatus = "current" | "retired" | "renamed" | "modified-managed" | "user-owned" | "unknown" | "conflict" | "diagnostic-state-only";
+export type ReconcileItem = {
+    path: string;
+    status: ReconcileStatus;
+    reason: string;
+    sha256?: string;
+    replacement?: string | null;
+};
+export type ReconcilePlan = {
+    schema_version: 2;
+    domain: "reconcile";
+    scope: Scope;
+    root: string;
+    inventory_version: string;
+    current: ReconcileItem[];
+    retired: ReconcileItem[];
+    renamed: ReconcileItem[];
+    modified_managed: ReconcileItem[];
+    user_owned: ReconcileItem[];
+    unknown: ReconcileItem[];
+    conflicts: ReconcileItem[];
+    diagnostic_state_only: ReconcileItem[];
+    operations: Array<{
+        path: string;
+        operation: "archive" | "remove" | "write";
+        sha256?: string;
+    }>;
+    plan_digest: string;
+    confirmation_digest?: string;
+    superseded_plan?: SupersededPlan;
+    confirmable: boolean;
+    digest?: string;
+    receipt_expires_at?: string;
+};
+export type ReconcileResult = {
+    status: "ok";
+    applied: true;
+    plan: ReconcilePlan;
+};
+export type ReconcileOptions = TransactionOptions;
+export declare class ReconcileError extends LifecycleError {
+}
+export declare function previewReconcile(scope: Scope, cwd?: string, home?: string): Promise<ReconcilePlan>;
+/** Build the ownership classification without receipts, locks, or recovery. */
+export declare function inspectReconcile(scope: Scope, cwd?: string, home?: string): Promise<ReconcilePlan>;
+export declare function applyReconcile(scope: Scope, confirmationDigest: string, cwd?: string, home?: string, options?: ReconcileOptions): Promise<ReconcileResult>;