oortmem 0.0.0-stage → 0.1.1

package/dist/commands/cloud.d.ts

@@ -0,0 +1,34 @@
+import { type CloudClient } from '../cloud.js';
+import { type Ctx } from '../util.js';
+/** One import request: at most this many memory lines and bytes (the API takes 1,000 and 10 MB). */
+export declare const IMPORT_CHUNK_LINES = 500;
+export declare const IMPORT_CHUNK_BYTES: number;
+/**
+ * Uploads one chunk. The API imports at most 1,000 lines a call and answers `next` (an index into
+ * the posted lines) when it stopped early; the same lines are posted again with `from = next`
+ * until it is done. `progress` gets how many of the chunk's lines are in after each call.
+ */
+export declare function uploadChunk(client: CloudClient, header: string, lines: string[], progress: (inChunk: number) => void): Promise<{
+    imported: number;
+    skipped: number;
+    reembedded: number;
+    calls: number;
+}>;
+/** `oort cloud use [--local]`: switch this machine's store. */
+export declare function cloudUseCommand(opts: {
+    local?: boolean;
+}, ctx: Ctx): Promise<number>;
+/** `oort cloud status [--json]` */
+export declare function cloudStatusCommand(opts: {
+    json?: boolean;
+}, ctx: Ctx): Promise<number>;
+/** `oort cloud import [--dry-run] [--yes]`: uploads the local store, resumable and idempotent. */
+export declare function cloudImportCommand(opts: {
+    dryRun?: boolean;
+    yes?: boolean;
+}, ctx: Ctx): Promise<number>;
+/** `oort cloud export [--out <file>] [--force]`: the whole cloud account in the v1 format. */
+export declare function cloudExportCommand(opts: {
+    out?: string;
+    force?: boolean;
+}, ctx: Ctx): Promise<number>;

package/dist/commands/cloud.js

@@ -0,0 +1,263 @@
+import * as path from 'node:path';
+import { principalGrant } from '@oortmem/core';
+import { OortCloudError, cloudUrl, createCloudClient, readCloudSettings, writeCloudSettings, } from '../cloud.js';
+import { keyLookup } from '../credentials.js';
+import { uiFor } from '../ui.js';
+import { Refusal, confirm, toJson, withWired, writeOwnerOnly } from '../util.js';
+import { EXPORT_VERSION, decoded, scopeKey } from './export.js';
+/** One import request: at most this many memory lines and bytes (the API takes 1,000 and 10 MB). */
+export const IMPORT_CHUNK_LINES = 500;
+export const IMPORT_CHUNK_BYTES = 8 * 1024 * 1024;
+/** A client for this machine's Oort key, whichever store mode is set. */
+async function clientFor(ctx) {
+    const url = cloudUrl(ctx.io.env);
+    if ('error' in url)
+        throw new Refusal(url.error);
+    const key = await keyLookup(ctx.io.env, ctx.keychain.read)('oort');
+    if (key === undefined) {
+        throw new Refusal('Oort Cloud needs the Oort key: run `oort login` first.');
+    }
+    return createCloudClient({
+        url: url.url,
+        key: key.key,
+        ...(ctx.fetch !== undefined && { fetch: ctx.fetch }),
+    });
+}
+/** Every memory in the local store (all projects of this machine's principal), oldest first. */
+async function localExport(w, ctx) {
+    const s = w.scope;
+    const grant = principalGrant({ orgId: s.orgId, customerId: s.customerId, agentId: s.agentId });
+    const all = await w.store.list(grant, { validOnly: false });
+    all.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt) || (a.id < b.id ? -1 : 1));
+    const lines = [];
+    const scopes = new Map();
+    let withEmbedding = 0;
+    for (const m of all) {
+        const full = await decoded(m, w.store, grant, ctx);
+        if (full.embedding !== undefined && full.embedding.length === w.config.embed.dimension)
+            withEmbedding++;
+        scopes.set(scopeKey(full.scope), full.scope);
+        lines.push(JSON.stringify(toJson(full)));
+    }
+    const manifest = {
+        oort: 'export',
+        version: EXPORT_VERSION,
+        exportedAt: new Date().toISOString(),
+        memories: lines.length,
+        scopes: [...scopes.values()],
+    };
+    return { manifest, lines, withEmbedding };
+}
+/** Chunks of export lines, each within the line and byte caps. */
+function chunks(lines, from) {
+    const out = [];
+    let cur = [];
+    let bytes = 0;
+    let start = from;
+    for (let i = from; i < lines.length; i++) {
+        const line = lines[i];
+        const b = Buffer.byteLength(line) + 1;
+        if (cur.length > 0 && (cur.length >= IMPORT_CHUNK_LINES || bytes + b > IMPORT_CHUNK_BYTES)) {
+            out.push({ start, lines: cur });
+            cur = [];
+            bytes = 0;
+            start = i;
+        }
+        cur.push(line);
+        bytes += b;
+    }
+    if (cur.length > 0)
+        out.push({ start, lines: cur });
+    return out;
+}
+/**
+ * Uploads one chunk. The API imports at most 1,000 lines a call and answers `next` (an index into
+ * the posted lines) when it stopped early; the same lines are posted again with `from = next`
+ * until it is done. `progress` gets how many of the chunk's lines are in after each call.
+ */
+export async function uploadChunk(client, header, lines, progress) {
+    const body = [header, ...lines];
+    const total = { imported: 0, skipped: 0, reembedded: 0, calls: 0 };
+    let from = 0;
+    for (;;) {
+        const r = await client.importLines(body, from);
+        total.calls++;
+        total.imported += r.imported;
+        total.skipped += r.skipped;
+        total.reembedded += r.reembedded;
+        if (r.next === undefined) {
+            progress(lines.length);
+            return total;
+        }
+        // Line 0 is the manifest, so line `next` of the body is line `next - 1` of the chunk.
+        if (!Number.isInteger(r.next) || r.next <= Math.max(from, 1) || r.next > lines.length) {
+            throw new Refusal('Oort Cloud stopped making progress on the import; run it again later.');
+        }
+        progress(r.next - 1);
+        from = r.next;
+    }
+}
+const fingerprintOf = (lines) => {
+    const id = (l) => l === undefined ? '' : (JSON.parse(l).id ?? '');
+    return `${lines.length}:${id(lines[0])}:${id(lines.at(-1))}`;
+};
+/** `oort cloud use [--local]`: switch this machine's store. */
+export async function cloudUseCommand(opts, ctx) {
+    const home = (await withWired(ctx, async (w) => w.config.home));
+    const settings = readCloudSettings(home);
+    const ui = uiFor(ctx.io);
+    if (opts.local === true) {
+        writeCloudSettings(home, { ...settings, store: 'local' });
+        ctx.io.out(ui.header('cloud', 'local store'));
+        ctx.io.out('This machine now uses the local store. Memories already in Oort Cloud stay there; `oort cloud export` downloads them.\n');
+        return 0;
+    }
+    const client = await clientFor(ctx);
+    const me = await client.whoami();
+    const local = await withWired(ctx, async (w) => (await localExport(w, ctx)).lines.length);
+    writeCloudSettings(home, { ...settings, store: 'cloud' });
+    ctx.io.out(ui.header('cloud', 'Oort Cloud'));
+    ctx.io.out(ui.kv([
+        ['account', me.account],
+        ['plan', me.plan],
+        ['store', `Oort Cloud (${client.url}), stored in the EU`],
+    ]));
+    ctx.io.out(`\nHooks, MCP and the oort commands now read and save in Oort Cloud.\n` +
+        (local > 0
+            ? `${local} ${local === 1 ? 'memory stays' : 'memories stay'} in the local store until you run \`oort cloud import\`.\n`
+            : '') +
+        'Switch back any time with `oort cloud use --local`.\n');
+    return 0;
+}
+/** `oort cloud status [--json]` */
+export async function cloudStatusCommand(opts, ctx) {
+    return withWired(ctx, async (w) => {
+        const settings = readCloudSettings(w.config.home);
+        let account;
+        let stats;
+        try {
+            const client = await clientFor(ctx);
+            account = await client.whoami();
+            stats = (await client.stats());
+        }
+        catch (e) {
+            if (!(e instanceof Refusal))
+                throw e;
+            account = { error: e.message };
+        }
+        const out = {
+            store: settings.store,
+            url: (() => {
+                const u = cloudUrl(ctx.io.env);
+                return 'url' in u ? u.url : u.error;
+            })(),
+            account,
+            ...(stats !== undefined && { cloud: stats }),
+            ...(settings.import !== undefined && { import: settings.import }),
+        };
+        if (opts.json === true) {
+            ctx.io.out(`${JSON.stringify(out, null, 2)}\n`);
+            return 0;
+        }
+        const ui = uiFor(ctx.io);
+        const acct = 'error' in account
+            ? ui.yellow(String(account['error']))
+            : `${String(account['account'])} (${String(account['plan'])})`;
+        ctx.io.out(ui.header('cloud', settings.store === 'cloud' ? 'Oort Cloud' : 'local store'));
+        ctx.io.out(ui.kv([
+            ['store', settings.store === 'cloud' ? `Oort Cloud (${out.url})` : 'local (this machine)'],
+            ['account', acct],
+            ...(stats !== undefined
+                ? [['cloud memories', String(stats['memories'])]]
+                : []),
+            ...(settings.import !== undefined
+                ? [
+                    [
+                        'import',
+                        `${settings.import.done}/${settings.import.total} uploaded${settings.import.done < settings.import.total ? ' (run `oort cloud import` to resume)' : ''}`,
+                    ],
+                ]
+                : []),
+        ]));
+        return 0;
+    });
+}
+/** `oort cloud import [--dry-run] [--yes]`: uploads the local store, resumable and idempotent. */
+export async function cloudImportCommand(opts, ctx) {
+    return withWired(ctx, async (w) => {
+        const ui = uiFor(ctx.io);
+        const { manifest, lines, withEmbedding } = await localExport(w, ctx);
+        const settings = readCloudSettings(w.config.home);
+        const fingerprint = fingerprintOf(lines);
+        const resume = settings.import?.fingerprint === fingerprint
+            ? Math.min(settings.import.done, lines.length)
+            : 0;
+        const plan = chunks(lines, resume);
+        const bytes = lines.slice(resume).reduce((n, l) => n + Buffer.byteLength(l) + 1, 0);
+        ctx.io.out(ui.header('cloud import', `${lines.length} local memories`));
+        ctx.io.out(ui.kv([
+            ['to upload', `${lines.length - resume}${resume > 0 ? ` (resuming after ${resume})` : ''}`],
+            ['size', `${(bytes / (1024 * 1024)).toFixed(2)} MB in ${plan.length} requests`],
+            [
+                'embeddings',
+                `${withEmbedding} reused; ${lines.length - withEmbedding} re-embedded in the cloud (counted toward your Pro embed use)`,
+            ],
+        ]));
+        if (opts.dryRun === true || lines.length === resume) {
+            if (lines.length === resume && lines.length > 0)
+                ctx.io.out('Already uploaded.\n');
+            return 0;
+        }
+        const go = await confirm(ctx.io, `Upload ${lines.length - resume} memories to Oort Cloud (EU)?`, opts.yes === true, 'upload them');
+        if (!go) {
+            ctx.io.out('Nothing uploaded.\n');
+            return 0;
+        }
+        const client = w.cloud ?? (await clientFor(ctx));
+        const header = JSON.stringify(manifest);
+        let done = resume;
+        let imported = 0;
+        let skipped = 0;
+        let reembedded = 0;
+        for (const c of plan) {
+            const r = await uploadChunk(client, header, c.lines, (inChunk) => {
+                done = c.start + inChunk;
+                writeCloudSettings(w.config.home, {
+                    ...readCloudSettings(w.config.home),
+                    import: { fingerprint, done, total: lines.length, updatedAt: new Date().toISOString() },
+                });
+            });
+            imported += r.imported;
+            skipped += r.skipped;
+            reembedded += r.reembedded;
+            ctx.io.out(`  uploaded ${done}/${lines.length}\n`);
+        }
+        ctx.io.out(`${ui.ok('done')}: ${imported} imported, ${skipped} already in the cloud, ${reembedded} re-embedded.\n`);
+        if (w.mode !== 'cloud')
+            ctx.io.out('Run `oort cloud use` to start using them.\n');
+        return 0;
+    });
+}
+/** `oort cloud export [--out <file>] [--force]`: the whole cloud account in the v1 format. */
+export async function cloudExportCommand(opts, ctx) {
+    const client = await clientFor(ctx);
+    let data;
+    try {
+        data = await client.exportText();
+    }
+    catch (e) {
+        if (e instanceof OortCloudError)
+            throw e;
+        throw new Refusal('Oort Cloud export failed; try again.');
+    }
+    const memories = Math.max(0, data.split('\n').filter((l) => l.length > 0).length - 1);
+    if (opts.out === undefined)
+        ctx.io.out(data);
+    else {
+        const file = path.resolve(ctx.io.cwd, opts.out);
+        writeOwnerOnly(file, data, opts.force === true);
+        ctx.io.out(`Exported ${memories} memories from Oort Cloud to ${file}\n`);
+    }
+    return 0;
+}
+//# sourceMappingURL=cloud.js.map

package/dist/commands/connect.d.ts

@@ -0,0 +1,14 @@
+import { type Change, type Host, type HostContext } from '../connectors.js';
+import { type Ui } from '../ui.js';
+import { type Ctx } from '../util.js';
+export declare function hostContext(ctx: Ctx): HostContext;
+export declare function hostArgs(args: string[]): Host[];
+/** The lines a change prints: header, key diff, what was written and how to undo it. */
+export declare function describeChange(ui: Ui, c: Change, cmd: string, opts?: {
+    dryRun?: boolean;
+    home?: string;
+}): string;
+/** `oort connect <host...> [--dry-run]` / `oort disconnect <host...> [--dry-run]` */
+export declare function connectCommand(action: 'connect' | 'disconnect', args: string[], opts: {
+    dryRun?: boolean;
+}, ctx: Ctx): Promise<number>;

package/dist/commands/connect.js

@@ -0,0 +1,99 @@
+import * as os from 'node:os';
+import { HOSTS, HOST_LABEL, connectHost, disconnectHost, isHost, } from '../connectors.js';
+import { uiFor } from '../ui.js';
+import { Refusal, echo, tilde } from '../util.js';
+import { hookCommandPath } from './install.js';
+/** Where the host starts stdio servers, which decides the memory scope. */
+function scopeNote(host) {
+    if (host === 'vscode' || host === 'cursor') {
+        return `the open workspace folder (${HOST_LABEL[host]} fills in --project \${workspaceFolder}), plus global memories`;
+    }
+    if (host === 'claude-desktop')
+        return 'the directory Claude Desktop starts it in (not a project, so usually global)';
+    return `the directory ${HOST_LABEL[host]} starts it in (usually your project), plus global memories; add "--project", "<dir>" to its args to pin one`;
+}
+const RELOAD = {
+    'claude-code': 'start a new Claude Code session; `/mcp` lists oort',
+    'claude-desktop': 'quit and reopen Claude Desktop',
+    codex: 'start a new Codex session; `codex mcp list` shows oort',
+    cursor: 'reload Cursor; Settings > MCP lists oort',
+    gemini: 'restart Gemini CLI; `/mcp` lists oort',
+    vscode: 'run "MCP: List Servers" and start oort',
+};
+export function hostContext(ctx) {
+    return { home: ctx.io.env['HOME'] || os.homedir(), env: ctx.io.env, platform: process.platform };
+}
+export function hostArgs(args) {
+    const hosts = [];
+    for (const a of args) {
+        if (!isHost(a)) {
+            throw new Refusal(`unknown host ${echo(a)}; expected one of ${HOSTS.join(', ')}. ChatGPT and claude.ai web need a remote MCP URL, which arrives with Oort Cloud.`);
+        }
+        if (!hosts.includes(a))
+            hosts.push(a);
+    }
+    return hosts;
+}
+/** The lines a change prints: header, key diff, what was written and how to undo it. */
+export function describeChange(ui, c, cmd, opts = {}) {
+    const label = HOST_LABEL[c.host];
+    const dryRun = opts.dryRun === true;
+    const show = (p) => tilde(p, opts.home ?? '');
+    let out = ui.header(`${c.action} ${c.host}`, show(c.file));
+    if (!c.changed) {
+        out +=
+            c.action === 'connect'
+                ? `${ui.ok(`${label} is already connected; nothing changed.`)}\n`
+                : `${ui.ok(`No oort entry in ${label}'s config; nothing changed.`)}\n`;
+        return out;
+    }
+    for (const line of c.diff) {
+        out += `${line.startsWith('+') ? ui.green(line) : line.startsWith('-') ? ui.red(line) : ui.yellow(line)}\n`;
+    }
+    if (dryRun)
+        return `${out}${ui.dim('(dry run: nothing written)')}\n`;
+    const rows = [];
+    if (c.action === 'connect') {
+        const how = c.via === 'claude-cli' ? ' (through `claude mcp add --scope user`)' : '';
+        out += `${ui.ok(`${c.created ? 'Created' : 'Updated'} ${show(c.file)}${how}: ${label} starts \`${cmd} mcp\`.`)}\n`;
+        rows.push(['scope', scopeNote(c.host)], ['next', RELOAD[c.host]]);
+    }
+    else {
+        const how = c.via === 'claude-cli' ? ' (through `claude mcp remove --scope user`)' : '';
+        out += `${ui.ok(`Removed the oort entry from ${show(c.file)}${how}.`)}\n`;
+    }
+    if (c.backup !== undefined)
+        rows.push(['backup', `${show(c.backup)} (before Oort first changed it)`]);
+    if (c.previous !== undefined)
+        rows.push(['previous', `${show(c.previous)} (just before this change)`]);
+    rows.push([
+        'undo',
+        c.action === 'connect' ? `oort disconnect ${c.host}` : `oort connect ${c.host}`,
+    ]);
+    return out + ui.kv(rows, { indent: 2 });
+}
+/** `oort connect <host...> [--dry-run]` / `oort disconnect <host...> [--dry-run]` */
+export async function connectCommand(action, args, opts, ctx) {
+    const hosts = hostArgs(args);
+    // Disconnect also removes an entry from an older install path, so it never needs the bin.
+    let cmd;
+    try {
+        cmd = hookCommandPath(ctx.io.entry);
+    }
+    catch (e) {
+        if (action === 'connect')
+            throw e;
+        cmd = 'oort';
+    }
+    const hc = hostContext(ctx);
+    const ui = uiFor(ctx.io);
+    const dryRun = opts.dryRun === true;
+    for (const host of hosts) {
+        const c = action === 'connect'
+            ? connectHost(host, hc, cmd, { dryRun })
+            : disconnectHost(host, hc, cmd, { dryRun });
+        ctx.io.out(describeChange(ui, c, cmd, { dryRun, home: hc.home }));
+    }
+    return 0;
+}
+//# sourceMappingURL=connect.js.map

package/dist/commands/consolidate.d.ts

@@ -0,0 +1,3 @@
+import { type Ctx } from '../util.js';
+/** `oort consolidate`: expire, re-tier and evict the memories visible from the cwd. */
+export declare function consolidateCommand(ctx: Ctx): Promise<number>;

package/dist/commands/consolidate.js

@@ -0,0 +1,24 @@
+import { filterFor } from '@oortmem/claude-code';
+import { consolidate } from '@oortmem/core';
+import { uiFor } from '../ui.js';
+import { Refusal, scopeLabel, withWired } from '../util.js';
+/** `oort consolidate`: expire, re-tier and evict the memories visible from the cwd. */
+export async function consolidateCommand(ctx) {
+    return withWired(ctx, async (w) => {
+        if (w.mode === 'cloud') {
+            throw new Refusal('In cloud mode Oort Cloud consolidates your memories itself (daily).');
+        }
+        const r = await consolidate(filterFor(w.scope), { store: w.store, config: w.config });
+        const ui = uiFor(ctx.io);
+        ctx.io.out(ui.header('consolidate', scopeLabel(w)));
+        ctx.io.out(ui.kv([
+            ['promoted', String(r.promoted.length)],
+            ['demoted', String(r.demoted.length)],
+            ['evicted', String(r.evicted.length)],
+            ['expired', String(r.expired.length)],
+            ['skipped', String(r.skipped)],
+        ]));
+        return 0;
+    });
+}
+//# sourceMappingURL=consolidate.js.map

package/dist/commands/doctor.d.ts

@@ -0,0 +1,15 @@
+import { type Ctx } from '../util.js';
+export type CheckStatus = 'ok' | 'warn' | 'fail' | 'info' | 'unknown';
+export interface Check {
+    group: 'keys' | 'hooks' | 'mcp' | 'store' | 'relay' | 'cloud';
+    name: string;
+    status: CheckStatus;
+    /** One line; never a key or a memory. */
+    detail: string;
+    /** One command or sentence that fixes a `warn` or `fail`. */
+    fix?: string;
+}
+/** `oort doctor [--json]`: every check, with a one-line fix per problem. Exits 1 if one fails. */
+export declare function doctorCommand(opts: {
+    json?: boolean;
+}, ctx: Ctx): Promise<number>;