alp-code 0.9.0

package/dist/src/execution/execution-store.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileExecutionStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function assertExecutionId(id) {
+    if (id.length === 0 ||
+        id === "." ||
+        id === ".." ||
+        id.includes("/") ||
+        id.includes("\\")) {
+        throw new Error(`invalid execution ID \`${id}\``);
+    }
+}
+async function pathExists(path) {
+    try {
+        await (0, promises_1.access)(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeSnapshot(path, value) {
+    await (0, promises_1.writeFile)(path, `${JSON.stringify(value, null, 2)}\n`, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 0o600,
+    });
+    await (0, promises_1.chmod)(path, 0o600);
+}
+class FileExecutionStore {
+    root;
+    constructor(options = {}) {
+        this.root = options.root ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".alp", "executions");
+    }
+    async create(input) {
+        if (input.policy.executionId !== input.state.executionId) {
+            throw new Error("policy and execution state IDs do not match");
+        }
+        assertExecutionId(input.policy.executionId);
+        await (0, promises_1.mkdir)(this.root, { recursive: true, mode: 0o700 });
+        await (0, promises_1.chmod)(this.root, 0o700);
+        const directory = (0, node_path_1.join)(this.root, input.policy.executionId);
+        if (await pathExists(directory)) {
+            throw new Error(`execution \`${input.policy.executionId}\` already exists`);
+        }
+        const staging = (0, node_path_1.join)(this.root, `.${input.policy.executionId}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+        const policyFileName = "policy.json";
+        const stateFileName = "state.json";
+        try {
+            await (0, promises_1.mkdir)(staging, { mode: 0o700 });
+            await (0, promises_1.mkdir)((0, node_path_1.join)(staging, "runtime"), { mode: 0o700 });
+            await (0, promises_1.mkdir)((0, node_path_1.join)(staging, "context"), { mode: 0o700 });
+            await writeSnapshot((0, node_path_1.join)(staging, policyFileName), input.policy);
+            await writeSnapshot((0, node_path_1.join)(staging, stateFileName), input.state);
+            await (0, promises_1.rename)(staging, directory);
+        }
+        catch (error) {
+            await (0, promises_1.rm)(staging, { recursive: true, force: true });
+            throw error;
+        }
+        const contextDirectory = (0, node_path_1.join)(directory, "context");
+        return Object.freeze({
+            directory,
+            stateFile: (0, node_path_1.join)(directory, stateFileName),
+            policyFile: (0, node_path_1.join)(directory, policyFileName),
+            runtimeDirectory: (0, node_path_1.join)(directory, "runtime"),
+            contextDirectory,
+            checkpointFile: (0, node_path_1.join)(contextDirectory, "checkpoint.json"),
+            continuityFile: (0, node_path_1.join)(contextDirectory, "continuity.md"),
+            compactEventsFile: (0, node_path_1.join)(contextDirectory, "compact-events.jsonl"),
+        });
+    }
+}
+exports.FileExecutionStore = FileExecutionStore;

package/dist/src/execution/identity-capsule.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdentityCapsule = createIdentityCapsule;
+const memory_grant_1 = require("../agents/memory-grant");
+const types_1 = require("./types");
+function memoryIdIsGranted(definition, id) {
+    const segments = id.split(":");
+    if (segments[0] === "private" && segments[1] !== definition.id) {
+        return false;
+    }
+    return definition.capabilities.memory.read.some((grant) => (0, memory_grant_1.memoryGrantCovers)(grant, id));
+}
+function memoryIsGranted(definition, entry) {
+    return ((entry.scope !== "private" || entry.ownerRole === definition.id) &&
+        memoryIdIsGranted(definition, entry.id));
+}
+function createIdentityCapsule(input) {
+    if (input.policy.role !== input.definition.id ||
+        input.policy.definitionHash.length === 0) {
+        throw new Error("execution policy does not match the resolved definition");
+    }
+    const workflow = input.definition.workflow.states[input.workflowState.currentState];
+    if (input.workflowState.workflowId !== input.definition.workflow.id ||
+        workflow === undefined) {
+        throw new Error("workflow state does not match the resolved definition");
+    }
+    const grantedTools = new Set(input.policy.allowedTools);
+    const allowedTools = workflow.allowedTools.filter((tool) => grantedTools.has(tool));
+    const entries = input.memoryContext.entries
+        .filter((entry) => memoryIsGranted(input.definition, entry))
+        .map((entry) => ({
+        id: entry.id,
+        kind: entry.kind,
+        content: entry.content,
+        version: entry.version,
+    }));
+    const omittedEntryIds = input.memoryContext.diagnostics.omittedEntryIds.filter((id) => memoryIdIsGranted(input.definition, id));
+    return (0, types_1.deepFreezeExecutionValue)({
+        executionId: input.policy.executionId,
+        definitionHash: input.policy.definitionHash,
+        policyHash: input.policy.policyHash,
+        role: input.definition.id,
+        displayName: input.definition.displayName,
+        instructions: input.definition.instructions(),
+        task: input.task,
+        activeWorkspace: input.policy.workspace,
+        memoryContext: {
+            invariantContext: input.memoryContext.invariantContext,
+            policyContext: input.memoryContext.policyContext,
+            entries,
+            diagnostics: {
+                characterBudget: input.memoryContext.diagnostics.characterBudget,
+                charactersUsed: entries.reduce((characters, entry) => characters + entry.content.length, 0),
+                truncated: omittedEntryIds.length > 0,
+                omittedEntryIds,
+            },
+        },
+        workflowState: { ...input.workflowState },
+        allowedTools,
+        outputContract: {
+            name: input.definition.output.name,
+            schema: input.definition.output.schema,
+        },
+    });
+}

package/dist/src/execution/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepFreezeExecutionValue = deepFreezeExecutionValue;
+function deepFreezeExecutionValue(value) {
+    if (value === null || typeof value !== "object" || Object.isFrozen(value)) {
+        return value;
+    }
+    for (const key of Reflect.ownKeys(value)) {
+        deepFreezeExecutionValue(value[key]);
+    }
+    return Object.freeze(value);
+}

package/dist/src/hooks/execution-bridge.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHookExecution = validateHookExecution;
+exports.finalizeExecution = finalizeExecution;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const registry_1 = require("../agents/registry");
+const execution_policy_1 = require("../execution/execution-policy");
+const workflow_runner_1 = require("../workflow/workflow-runner");
+async function validateHookExecution(input) {
+    const { policy } = await loadExecution(input);
+    return { executionId: policy.executionId, role: policy.role };
+}
+function executionRoot(input) {
+    return input.executionRoot ?? process.env.ALP_EXECUTION_ROOT ?? (0, node_path_1.join)(process.env.HOME ?? "", ".alp", "executions");
+}
+function assertExecutionId(id) {
+    if (!/^exec_[a-zA-Z0-9_-]+$/.test(id))
+        throw new Error("missing or invalid execution ID");
+}
+async function loadExecution(input) {
+    assertExecutionId(input.executionId);
+    const directory = (0, node_path_1.join)(executionRoot(input), input.executionId);
+    const [policy, state] = await Promise.all([
+        (0, promises_1.readFile)((0, node_path_1.join)(directory, "policy.json"), "utf8").then((value) => JSON.parse(value)),
+        (0, promises_1.readFile)((0, node_path_1.join)(directory, "state.json"), "utf8").then((value) => JSON.parse(value)),
+    ]);
+    if (policy.executionId !== input.executionId || state.executionId !== input.executionId)
+        throw new Error("execution ID mismatch");
+    if (state.policyHash !== policy.policyHash)
+        throw new Error("execution state policy hash mismatch");
+    const definition = registry_1.agentRegistry.get(policy.role);
+    const expected = (0, execution_policy_1.createExecutionPolicy)({
+        executionId: policy.executionId,
+        definition,
+        workspace: policy.workspace,
+        workspaceMode: policy.workspaceMode,
+        createdAt: policy.createdAt,
+    });
+    if (JSON.stringify(expected) !== JSON.stringify(policy))
+        throw new Error("execution policy snapshot is invalid or stale");
+    return { policy, state };
+}
+/** Walk a still-running workflow forward to its terminal state so output can be submitted. */
+function advanceToOutput(runner, definition, state) {
+    let candidate = state;
+    while (candidate.status === "running") {
+        const transitions = definition.workflow.states[candidate.currentState].transitions;
+        if (transitions.length !== 1)
+            throw new Error(`workflow state \`${candidate.currentState}\` has no unambiguous output path`);
+        candidate = runner.transition(definition.workflow, candidate, transitions[0]);
+    }
+    return candidate;
+}
+async function persistState(input, state) {
+    const file = (0, node_path_1.join)(executionRoot(input), input.executionId, "state.json");
+    const temporary = `${file}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    await (0, promises_1.writeFile)(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    await (0, promises_1.rename)(temporary, file);
+    await (0, promises_1.chmod)(file, 0o600);
+}
+async function finalizeExecution(input) {
+    const { policy, state } = await loadExecution(input);
+    const definition = registry_1.agentRegistry.get(policy.role);
+    if (state.workflow.status === "completed")
+        return { ok: true, status: "completed", issues: [] };
+    if (state.workflow.status === "failed")
+        return { ok: false, status: "failed", issues: ["output repair budget exhausted"] };
+    const runner = new workflow_runner_1.WorkflowRunner();
+    const workflow = advanceToOutput(runner, definition, state.workflow);
+    const result = runner.submitOutput(workflow, definition.output, input.output);
+    await persistState(input, {
+        ...state,
+        status: result.state.status,
+        workflow: result.state,
+        ...(result.validation.ok ? { output: result.validation.value ?? input.output } : {}),
+    });
+    return {
+        ok: result.validation.ok,
+        status: result.state.status,
+        issues: result.validation.ok ? [] : result.validation.issues,
+    };
+}

package/dist/src/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALP_CORE_VERSION = void 0;
+exports.ALP_CORE_VERSION = 1;

package/dist/src/memory/adapters/markdown-file-store.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownFileStore = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const errors_1 = require("../errors");
+const memory_service_1 = require("../memory-service");
+const memory_path_mapper_1 = require("./memory-path-mapper");
+const memory_grant_1 = require("../../agents/memory-grant");
+const MEMORY_KINDS = new Set([
+    "fact",
+    "decision",
+    "reference",
+    "log",
+    "draft",
+]);
+let temporarySequence = 0;
+function inferKind(content) {
+    const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+    const value = frontmatter?.match(/^kind:\s*([^\s#]+)\s*$/m)?.[1];
+    return value && MEMORY_KINDS.has(value) ? value : "reference";
+}
+async function pathExists(path) {
+    try {
+        await (0, promises_1.access)(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function atomicWrite(path, content) {
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(path), { recursive: true });
+    const temporary = (0, node_path_1.join)((0, node_path_1.dirname)(path), `.${(0, node_path_1.basename)(path)}.${process.pid}.${++temporarySequence}.tmp`);
+    try {
+        await (0, promises_1.writeFile)(temporary, content, { encoding: "utf8", mode: 0o600 });
+        await (0, promises_1.rename)(temporary, path);
+    }
+    finally {
+        await (0, promises_1.rm)(temporary, { force: true });
+    }
+}
+class MarkdownFileStore {
+    mapper;
+    metadataPath;
+    now;
+    metadata;
+    initializing;
+    mutations = Promise.resolve();
+    constructor(options) {
+        this.mapper = new memory_path_mapper_1.MemoryPathMapper(options.root);
+        this.metadataPath = (0, node_path_1.join)(this.mapper.root, ".alp-memory-index.json");
+        this.now = options.now ?? (() => new Date());
+    }
+    async initialize() {
+        if (this.metadata)
+            return;
+        if (!this.initializing) {
+            this.initializing = (async () => {
+                await (0, promises_1.mkdir)(this.mapper.root, { recursive: true });
+                try {
+                    const parsed = JSON.parse(await (0, promises_1.readFile)(this.metadataPath, "utf8"));
+                    if (parsed.formatVersion !== 1 || !parsed.entries || typeof parsed.entries !== "object") {
+                        throw new Error("unsupported memory metadata index");
+                    }
+                    this.metadata = { formatVersion: 1, entries: { ...parsed.entries } };
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                    this.metadata = await this.rebuildMetadata();
+                    await this.persistMetadata();
+                }
+            })();
+        }
+        await this.initializing;
+    }
+    async rebuildMetadata() {
+        const entries = {};
+        const addFile = async (id, path) => {
+            const [content, metadata] = await Promise.all([(0, promises_1.readFile)(path, "utf8"), (0, promises_1.stat)(path)]);
+            entries[id] = {
+                version: 1,
+                kind: inferKind(content),
+                createdAt: metadata.birthtime.toISOString(),
+                updatedAt: metadata.mtime.toISOString(),
+            };
+        };
+        const nestedMarkdown = async (directory, idPrefix) => {
+            let directoryMetadata;
+            try {
+                directoryMetadata = await (0, promises_1.lstat)(directory);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return;
+                throw error;
+            }
+            if (!directoryMetadata.isDirectory() || directoryMetadata.isSymbolicLink())
+                return;
+            for (const item of await (0, promises_1.readdir)(directory, { withFileTypes: true })) {
+                if (item.isFile() && (0, node_path_1.extname)(item.name) === ".md") {
+                    await addFile([...idPrefix, (0, node_path_1.parse)(item.name).name].join(":"), (0, node_path_1.join)(directory, item.name));
+                }
+                else if (item.isDirectory() && !item.isSymbolicLink()) {
+                    await nestedMarkdown((0, node_path_1.join)(directory, item.name), [...idPrefix, item.name]);
+                }
+            }
+        };
+        await nestedMarkdown((0, node_path_1.join)(this.mapper.root, "shared"), ["shared"]);
+        for (const scope of ["projects", "private"]) {
+            const scopeRoot = (0, node_path_1.join)(this.mapper.root, scope);
+            let scopeMetadata;
+            try {
+                scopeMetadata = await (0, promises_1.lstat)(scopeRoot);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            if (!scopeMetadata.isDirectory() || scopeMetadata.isSymbolicLink())
+                continue;
+            for (const owner of await (0, promises_1.readdir)(scopeRoot, { withFileTypes: true })) {
+                if (!owner.isDirectory() || owner.isSymbolicLink())
+                    continue;
+                await nestedMarkdown((0, node_path_1.join)(scopeRoot, owner.name), [scope === "projects" ? "project" : "private", owner.name]);
+            }
+        }
+        return { formatVersion: 1, entries };
+    }
+    async persistMetadata() {
+        await atomicWrite(this.metadataPath, `${JSON.stringify(this.metadata, null, 2)}\n`);
+    }
+    async exclusive(action) {
+        const result = this.mutations.then(action, action);
+        this.mutations = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async settledMetadata() {
+        await this.initialize();
+        await this.mutations;
+        return this.metadata;
+    }
+    async entry(id, metadata) {
+        const parsed = (0, memory_service_1.parseMemoryId)(id);
+        const path = await this.mapper.safePathFor(id);
+        let content;
+        try {
+            content = await (0, promises_1.readFile)(path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                throw new errors_1.MemoryEntryNotFoundError(id);
+            throw error;
+        }
+        return Object.freeze({
+            id,
+            scope: parsed.scope,
+            ...(parsed.ownerRole === undefined ? {} : { ownerRole: parsed.ownerRole }),
+            ...(parsed.projectId === undefined ? {} : { projectId: parsed.projectId }),
+            kind: metadata.kind,
+            content,
+            version: metadata.version,
+            createdAt: metadata.createdAt,
+            updatedAt: metadata.updatedAt,
+        });
+    }
+    async search(query) {
+        const metadata = await this.settledMetadata();
+        const needle = query.text?.toLocaleLowerCase();
+        const results = [];
+        for (const id of Object.keys(metadata.entries).sort()) {
+            if (!(0, memory_grant_1.memoryGrantCovers)(query.scope, id))
+                continue;
+            const item = metadata.entries[id];
+            if (query.kinds && !query.kinds.includes(item.kind))
+                continue;
+            const entry = await this.entry(id, item);
+            if (needle && !`${entry.id}\n${entry.content}`.toLocaleLowerCase().includes(needle))
+                continue;
+            results.push(entry);
+            if (query.limit !== undefined && results.length >= query.limit)
+                break;
+        }
+        return Object.freeze(results);
+    }
+    async get(id) {
+        (0, memory_service_1.parseMemoryId)(id);
+        const metadata = await this.settledMetadata();
+        const item = metadata.entries[id];
+        return item ? this.entry(id, item) : null;
+    }
+    async create(input) {
+        return this.exclusive(async () => {
+            await this.initialize();
+            const path = await this.mapper.safePathFor(input.id, true);
+            if (this.metadata.entries[input.id] || (await pathExists(path))) {
+                throw new errors_1.MemoryEntryAlreadyExistsError(input.id);
+            }
+            const timestamp = this.now().toISOString();
+            await atomicWrite(path, input.content);
+            const item = {
+                version: 1,
+                kind: input.kind,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+            };
+            this.metadata.entries[input.id] = item;
+            await this.persistMetadata();
+            return this.entry(input.id, item);
+        });
+    }
+    async update(id, input) {
+        return this.exclusive(async () => {
+            await this.initialize();
+            (0, memory_service_1.parseMemoryId)(id);
+            const current = this.metadata.entries[id];
+            if (!current)
+                throw new errors_1.MemoryEntryNotFoundError(id);
+            if (current.version !== input.expectedVersion) {
+                throw new errors_1.MemoryVersionConflictError(id, input.expectedVersion, current.version);
+            }
+            const path = await this.mapper.safePathFor(id);
+            const content = input.content ?? (await (0, promises_1.readFile)(path, "utf8"));
+            await atomicWrite(path, content);
+            const item = {
+                version: current.version + 1,
+                kind: input.kind ?? current.kind,
+                createdAt: current.createdAt,
+                updatedAt: this.now().toISOString(),
+            };
+            this.metadata.entries[id] = item;
+            await this.persistMetadata();
+            return this.entry(id, item);
+        });
+    }
+    async delete(id, expectedVersion) {
+        return this.exclusive(async () => {
+            await this.initialize();
+            (0, memory_service_1.parseMemoryId)(id);
+            const current = this.metadata.entries[id];
+            if (!current)
+                throw new errors_1.MemoryEntryNotFoundError(id);
+            if (current.version !== expectedVersion) {
+                throw new errors_1.MemoryVersionConflictError(id, expectedVersion, current.version);
+            }
+            const path = await this.mapper.safePathFor(id);
+            await (0, promises_1.rm)(path);
+            delete this.metadata.entries[id];
+            await this.persistMetadata();
+        });
+    }
+}
+exports.MarkdownFileStore = MarkdownFileStore;

package/dist/src/memory/adapters/memory-api-client.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/memory/adapters/memory-path-mapper.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryPathMapper = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const memory_service_1 = require("../memory-service");
+function isWithin(root, target) {
+    const relation = (0, node_path_1.relative)(root, target);
+    return relation === "" || (!relation.startsWith("..") && !(0, node_path_1.isAbsolute)(relation));
+}
+async function nearestExistingDirectory(path) {
+    let candidate = path;
+    while (true) {
+        try {
+            const metadata = await (0, promises_1.lstat)(candidate);
+            if (metadata.isDirectory() || metadata.isSymbolicLink())
+                return candidate;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const parent = (0, node_path_1.dirname)(candidate);
+        if (parent === candidate)
+            return candidate;
+        candidate = parent;
+    }
+}
+class MemoryPathMapper {
+    root;
+    constructor(root) {
+        this.root = (0, node_path_1.resolve)(root);
+    }
+    pathFor(id) {
+        const parsed = (0, memory_service_1.parseMemoryId)(id);
+        const directories = parsed.pathSegments.slice(0, -1);
+        const filename = `${parsed.pathSegments.at(-1)}.md`;
+        const path = parsed.scope === "shared"
+            ? (0, node_path_1.join)(this.root, "shared", ...directories, filename)
+            : parsed.scope === "project"
+                ? (0, node_path_1.join)(this.root, "projects", parsed.projectId, ...directories, filename)
+                : (0, node_path_1.join)(this.root, "private", parsed.ownerRole, ...directories, filename);
+        if (!isWithin(this.root, path))
+            throw new Error(`memory path escapes root for \`${id}\``);
+        return path;
+    }
+    async safePathFor(id, createParent = false) {
+        const path = this.pathFor(id);
+        await (0, promises_1.mkdir)(this.root, { recursive: true });
+        const rootReal = await (0, promises_1.realpath)(this.root);
+        const existingParent = await nearestExistingDirectory((0, node_path_1.dirname)(path));
+        const existingReal = await (0, promises_1.realpath)(existingParent);
+        if (!isWithin(rootReal, existingReal)) {
+            throw new Error(`memory path symlink escape for \`${id}\``);
+        }
+        if (createParent) {
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(path), { recursive: true });
+            const parentReal = await (0, promises_1.realpath)((0, node_path_1.dirname)(path));
+            if (!isWithin(rootReal, parentReal)) {
+                throw new Error(`memory path symlink escape for \`${id}\``);
+            }
+        }
+        try {
+            const targetMetadata = await (0, promises_1.lstat)(path);
+            if (targetMetadata.isSymbolicLink()) {
+                throw new Error(`memory path symlink escape for \`${id}\``);
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        return path;
+    }
+}
+exports.MemoryPathMapper = MemoryPathMapper;

package/dist/src/memory/adapters/remote-api-store.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteApiStore = void 0;
+class RemoteApiStore {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    search(query) {
+        return this.client.search(query);
+    }
+    get(id) {
+        return this.client.get(id);
+    }
+    create(input) {
+        return this.client.create(input);
+    }
+    update(id, input) {
+        return this.client.update(id, input);
+    }
+    delete(id, expectedVersion) {
+        return this.client.delete(id, expectedVersion);
+    }
+}
+exports.RemoteApiStore = RemoteApiStore;

package/dist/src/memory/context-ranker.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeterministicContextRanker = void 0;
+function matchScore(entry, queries) {
+    const terms = queries
+        .flatMap((query) => query.text?.toLocaleLowerCase().split(/\s+/) ?? [])
+        .filter(Boolean);
+    if (terms.length === 0)
+        return 0;
+    const haystack = `${entry.id}\n${entry.content}`.toLocaleLowerCase();
+    return terms.reduce((score, term) => score + (haystack.includes(term) ? 1 : 0), 0);
+}
+class DeterministicContextRanker {
+    rank(entries, queries) {
+        return [...entries].sort((left, right) => {
+            const score = matchScore(right, queries) - matchScore(left, queries);
+            return score || right.updatedAt.localeCompare(left.updatedAt) || left.id.localeCompare(right.id);
+        });
+    }
+}
+exports.DeterministicContextRanker = DeterministicContextRanker;