@agentage/cli 0.37.2 → 0.38.1

package/dist/lib/update/update-cache.js

@@ -1,6 +1,6 @@
-import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureConfigDir, getConfigDir } from '../fs/config.js';
+import { isRecord, readJson, writeJsonAtomic } from '../fs/json-file.js';
 import { fetchJsonUnref } from '../net/http.js';
 import { compareVersions, INSTALL_HINT, REGISTRY_URL } from './update-check.js';
 import { VERSION } from '../../utils/version.js';
@@ -8,18 +8,14 @@ const CACHE_FILE = 'update-check.json';
 const TTL_MS = 60 * 60 * 1000; // passive checks refresh at most once an hour
 const BG_TIMEOUT_MS = 3000; // hard cap on the whole background attempt, connect included
 const cachePath = () => join(getConfigDir(), CACHE_FILE);
-export const readUpdateCache = () => {
-    try {
-        const c = JSON.parse(readFileSync(cachePath(), 'utf-8'));
-        return typeof c.checkedAt === 'number' ? c : null;
-    }
-    catch {
-        return null;
-    }
-};
+// A wrong-typed field reads as no cache: the post-action hint must never throw.
+export const isUpdateCache = (value) => isRecord(value) &&
+    typeof value['checkedAt'] === 'number' &&
+    (value['latest'] === null || typeof value['latest'] === 'string');
+export const readUpdateCache = () => readJson(cachePath(), isUpdateCache);
 const writeUpdateCache = (latest, now) => {
     ensureConfigDir();
-    writeFileSync(cachePath(), JSON.stringify({ checkedAt: now, latest }) + '\n', 'utf-8');
+    writeJsonAtomic(cachePath(), { checkedAt: now, latest });
 };
 // The one dim hint line printed after a command, read purely from the cache (never the network),
 // only when the cached latest is newer than us. null = print nothing.

package/dist/lib/update/update-check.js

@@ -7,10 +7,7 @@ export const REGISTRY_URL = 'https://registry.npmjs.org/@agentage/cli/latest';
 // Compare dotted numeric versions (major.minor.patch); prerelease/build suffixes are
 // ignored - good enough for an update hint. Returns -1 / 0 / 1.
 export const compareVersions = (a, b) => {
-    const parts = (v) => v
-        .split('-')[0]
-        .split('.')
-        .map((n) => Number.parseInt(n, 10) || 0);
+    const parts = (v) => (v.split('-')[0] ?? '').split('.').map((n) => Number.parseInt(n, 10) || 0);
     const pa = parts(a);
     const pb = parts(b);
     for (let i = 0; i < 3; i++) {

package/dist/plugin.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_API_VERSION = "1.0.0";

package/dist/plugin.js

@@ -0,0 +1,2 @@
+// The plugin contract is versioned apart from the CLI, so plugins pin it, not a CLI release.
+export const PLUGIN_API_VERSION = '1.0.0';

package/dist/program.d.ts

@@ -1 +1,18 @@
-export declare const run: () => Promise<void>;
+import { Command } from 'commander';
+import { type SetupOptions } from './commands/auth/setup.js';
+import { type StatusOptions } from './commands/status/status.js';
+import { type UpdateOptions } from './commands/update/update.js';
+export interface ProgramDeps {
+    setup: (opts: SetupOptions) => Promise<void>;
+    status: (opts: StatusOptions) => Promise<void>;
+    update: (opts: UpdateOptions) => Promise<void>;
+    updateHint: () => string | null;
+    refreshUpdateCache: () => Promise<void>;
+    writeOut: (text: string) => void;
+    writeErr: (text: string) => void;
+}
+export declare const EXIT_OK = 0;
+export declare const EXIT_FAILED = 1;
+export declare const EXIT_USAGE = 2;
+export declare const createProgram: (deps?: ProgramDeps) => Command;
+export declare const run: (argv?: string[], deps?: ProgramDeps) => Promise<number>;

package/dist/program.js

@@ -1,50 +1,81 @@
 import chalk from 'chalk';
-import { Command } from 'commander';
-import { registerDaemon } from './commands/daemon/daemon-cmd.js';
-import { registerMemory } from './commands/memory/memory.js';
-import { registerSetup } from './commands/auth/setup.js';
-import { registerStatus } from './commands/status/status.js';
-import { registerUpdate } from './commands/update/update.js';
-import { registerVault } from './commands/vault/vault.js';
-import { disableDaemon } from './lib/daemon/daemon-pref.js';
+import { Command, CommanderError } from 'commander';
+import { registerSetup, runSetup } from './commands/auth/setup.js';
+import { registerStatus, runStatus } from './commands/status/status.js';
+import { registerUpdate, runUpdate } from './commands/update/update.js';
+import { ensureSignedIn, signOut } from './lib/auth/sign-in.js';
 import { refreshUpdateCache, updateHint } from './lib/update/update-cache.js';
 import { VERSION } from './utils/version.js';
-const program = new Command();
-program
-    .name('agentage')
-    .description('The offline-first terminal client for agentage Memory')
-    .version(VERSION)
-    .option('--no-daemon', 'run memory verbs in-process instead of via the daemon');
-program.addHelpText('after', '\nNew here? Run: agentage vault add <name> --local, or agentage setup to connect an account.');
-program.hook('preAction', () => {
-    if (program.opts().daemon === false)
-        disableDaemon();
-});
-// After any command (except the update-aware ones, which report richer state themselves), print a
-// one-line hint from the cache, then kick a fire-and-forget refresh. Never awaited, never throws -
-// the command output is already done and the cache-only read keeps this instant. The hint is
-// suppressed under --json so it never corrupts machine-readable output.
-program.hook('postAction', (_thisCommand, actionCommand) => {
-    const name = actionCommand.name();
-    if (name === 'status' || name === 'update')
+const defaultDeps = {
+    setup: (opts) => runSetup(opts, {
+        ensureSignedIn: (signInOpts) => ensureSignedIn(signInOpts),
+        signOut: () => signOut(),
+        printStatus: () => runStatus({}),
+    }),
+    status: (opts) => runStatus(opts),
+    update: (opts) => runUpdate(opts),
+    updateHint,
+    refreshUpdateCache: () => refreshUpdateCache(),
+    writeOut: (text) => void process.stdout.write(text),
+    writeErr: (text) => void process.stderr.write(text),
+};
+export const EXIT_OK = 0;
+export const EXIT_FAILED = 1;
+export const EXIT_USAGE = 2;
+const ACTION_FAILED = 'agentage.actionFailed';
+const messageOf = (err) => (err instanceof Error ? err.message : String(err));
+// One failure path for every command: a red stderr line, then exit 1 through run().
+const withAction = (deps, fn, prefix = '') => async (opts) => {
+    try {
+        await fn(opts);
+    }
+    catch (err) {
+        deps.writeErr(`${chalk.red(`${prefix}${messageOf(err)}`)}\n`);
+        throw new CommanderError(EXIT_FAILED, ACTION_FAILED, messageOf(err));
+    }
+};
+// status and update report update state themselves; the hint never touches --json stdout.
+const hintAfter = (deps) => (_program, action) => {
+    if (action.name() === 'status' || action.name() === 'update')
         return;
-    if (!actionCommand.opts()['json']) {
-        const hint = updateHint();
-        if (hint)
-            console.error(chalk.dim(hint)); // stderr: never corrupt piped stdout
+    const hint = action.opts()['json'] ? null : deps.updateHint();
+    if (hint)
+        deps.writeErr(`${chalk.dim(hint)}\n`);
+    void deps.refreshUpdateCache();
+};
+export const createProgram = (deps = defaultDeps) => {
+    const program = new Command()
+        .name('agentage')
+        .description('Connect this machine to agentage from the terminal')
+        .version(VERSION)
+        .exitOverride()
+        .configureOutput({ writeOut: deps.writeOut, writeErr: deps.writeErr })
+        .addHelpText('after', '\nNew here? Run: agentage setup to connect this machine.')
+        .hook('postAction', hintAfter(deps));
+    registerSetup(program, withAction(deps, deps.setup, 'Setup failed: '));
+    registerStatus(program, withAction(deps, deps.status));
+    registerUpdate(program, withAction(deps, deps.update));
+    return program;
+};
+// Commander's own exit 0 (--help, --version) stays 0; any other commander error is usage.
+const exitCodeOf = (err, deps) => {
+    if (!(err instanceof CommanderError)) {
+        deps.writeErr(`${chalk.red(messageOf(err))}\n`);
+        return EXIT_FAILED;
+    }
+    if (err.code === ACTION_FAILED)
+        return EXIT_FAILED;
+    return err.exitCode === 0 ? EXIT_OK : EXIT_USAGE;
+};
+// Returns the exit code instead of exiting, so piped stdout is never cut short.
+export const run = async (argv = process.argv, deps = defaultDeps) => {
+    if (process.env['NO_COLOR'])
+        chalk.level = 0; // chalk ignores NO_COLOR on its own
+    try {
+        await createProgram(deps).parseAsync(argv);
+        return EXIT_OK;
+    }
+    catch (err) {
+        return exitCodeOf(err, deps);
     }
-    void refreshUpdateCache();
-});
-registerSetup(program);
-registerStatus(program);
-registerVault(program);
-registerMemory(program);
-registerDaemon(program);
-registerUpdate(program);
-// Called by the bin (src/cli.ts) once the observability bootstrap has run.
-export const run = async () => {
-    await program.parseAsync().catch((err) => {
-        console.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    });
 };

package/package.json

@@ -1,10 +1,21 @@
 {
   "name": "@agentage/cli",
-  "version": "0.37.2",
+  "version": "0.38.1",
   "description": "The agentage CLI - connect this machine to agentage from the terminal",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "default": "./dist/plugin.js"
+    },
+    "./package.json": "./package.json"
+  },
   "bin": {
     "agentage": "./dist/cli.js"
   },
@@ -25,11 +36,11 @@
   },
   "scripts": {
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
-    "type-check": "tsc --noEmit",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
-    "format": "prettier --write \"{src,e2e}/**/*.ts\"",
-    "format:check": "prettier --check \"{src,e2e}/**/*.ts\"",
+    "type-check": "tsc --noEmit && tsc -p fixtures",
+    "lint": "eslint src e2e fixtures",
+    "lint:fix": "eslint src e2e fixtures --fix",
+    "format": "prettier --write \"{src,e2e}/**/*.ts\" \"fixtures/**/*.{js,json}\"",
+    "format:check": "prettier --check \"{src,e2e}/**/*.ts\" \"fixtures/**/*.{js,json}\"",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
@@ -40,17 +51,11 @@
     "prepublishOnly": "npm run verify"
   },
   "dependencies": {
-    "@agentage/memory-core": "^0.5.0",
-    "@agentage/observability": "^1.4.0",
-    "@agentage/server-memory": "^0.11.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opentelemetry/api": "^1.9.0",
     "chalk": "^6.0.0",
     "commander": "^15.0.0",
     "open": "^11.0.0"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.135.0",
     "@playwright/test": "latest",
     "@types/node": "latest",
     "@typescript-eslint/eslint-plugin": "latest",

package/dist/commands/daemon/daemon-cmd.d.ts

@@ -1,2 +0,0 @@
-import { type Command } from 'commander';
-export declare const registerDaemon: (program: Command) => void;

package/dist/commands/daemon/daemon-cmd.js

@@ -1,107 +0,0 @@
-import chalk from 'chalk';
-import { isDaemonRunning, resolvePort, signalPid, stopDaemonSafely, } from '../../daemon/lifecycle.js';
-import { health, mismatchNotice, spawnDaemon, syncStatus } from '../../lib/daemon/daemon-client.js';
-const startAction = async (opts = {}) => {
-    const port = resolvePort();
-    const existing = await health(port);
-    if (existing) {
-        console.log(chalk.gray(`Daemon already running (pid ${existing.pid}, port ${port}).`));
-        return;
-    }
-    const noMcp = opts.mcp === false;
-    const outcome = await spawnDaemon(port, { noMcp });
-    if (!outcome.ok) {
-        if (outcome.reason === 'port-in-use') {
-            console.error(chalk.red(`Port ${port} is in use by another process - set AGENTAGE_DAEMON_PORT to use a different port.`));
-        }
-        else {
-            console.error(chalk.red('Daemon failed to start.'));
-        }
-        process.exitCode = 1;
-        return;
-    }
-    const h = await health(port);
-    const mcp = noMcp ? 'off' : 'on';
-    console.log(chalk.green(`Daemon started (pid ${h?.pid ?? '?'}, port ${port}, mcp ${mcp}).`));
-};
-// Detect the daemon the same way `start` does (tokenless /health), so a legacy daemon that never
-// wrote this config dir's pidfile is not misreported as "not running". With a pidfile we own, use
-// the safe pid-confirming stop; otherwise fall back to signalling the pid /health reports, or - if
-// none is available - report the truth rather than a false "not running".
-const stopAction = async () => {
-    if (isDaemonRunning()) {
-        if (await stopDaemonSafely())
-            console.log(chalk.green('Daemon stopped.'));
-        return;
-    }
-    const port = resolvePort();
-    const h = await health(port);
-    if (!h) {
-        console.log(chalk.gray('Daemon is not running.'));
-        return;
-    }
-    if (typeof h.pid === 'number' && signalPid(h.pid)) {
-        console.log(chalk.green(`Daemon stopped (pid ${h.pid}).`));
-        return;
-    }
-    const who = typeof h.pid === 'number' ? `pid ${h.pid}` : `port ${port}`;
-    console.error(chalk.yellow(`Daemon is running (${who}) but has no pidfile to stop it safely; stop it with: kill ${h.pid ?? '<pid>'}`));
-    process.exitCode = 1;
-};
-const statusAction = async () => {
-    const port = resolvePort();
-    const h = await health(port);
-    if (!h) {
-        console.log(isDaemonRunning()
-            ? chalk.yellow(`Daemon pid file present but unreachable on port ${port}.`)
-            : chalk.gray('Daemon is not running.'));
-        return;
-    }
-    console.log(`pid      ${h.pid ?? '?'}`);
-    console.log(`port     ${port}`);
-    if (typeof h.uptime === 'number')
-        console.log(`uptime   ${h.uptime}s`);
-    if (typeof h.served === 'number')
-        console.log(`served   ${h.served}`);
-    console.log(`mcp      ${h.mcp === false ? 'off' : 'on'}`);
-    console.log(`version  ${h.version}`);
-    const notice = mismatchNotice(h.version);
-    if (notice)
-        console.log(chalk.yellow(notice));
-    const sync = await syncStatus(port);
-    if (sync && sync.vaults.length > 0) {
-        console.log('sync');
-        for (const v of sync.vaults) {
-            const cadence = v.intervalSeconds > 0 ? `every ${v.intervalSeconds}s` : 'manual';
-            const state = v.running
-                ? 'running'
-                : v.lastError
-                    ? `error: ${v.lastError}`
-                    : v.lastRun
-                        ? `ok ${v.lastRun}`
-                        : 'scheduled';
-            console.log(`  ${v.vault.padEnd(16)} ${cadence.padEnd(12)} ${state}`);
-        }
-    }
-    if (sync?.discover && sync.discover.roots.length > 0) {
-        console.log(`discover roots (${sync.discover.roots.length})`);
-        for (const root of sync.discover.roots)
-            console.log(`  ${root}`);
-    }
-};
-export const registerDaemon = (program) => {
-    const daemon = program.command('daemon').description('Manage the local engine daemon');
-    daemon
-        .command('start')
-        .description('Start the daemon (idempotent)')
-        .option('--no-mcp', 'do not serve the local MCP endpoint at /mcp')
-        .action((opts) => startAction(opts));
-    daemon
-        .command('stop')
-        .description('Stop the daemon')
-        .action(() => stopAction());
-    daemon
-        .command('status')
-        .description('Show the daemon pid, uptime, and version')
-        .action(() => statusAction());
-};

package/dist/commands/memory/memory-verbs.d.ts

@@ -1,21 +0,0 @@
-import { type MemoryClient } from '../../lib/memory/memory-client.js';
-export interface CommonOpts {
-    vault?: string;
-    json?: boolean;
-}
-export declare const runSearch: (query: string, opts: CommonOpts & {
-    limit?: string;
-}, client?: MemoryClient) => Promise<void>;
-export declare const runRead: (ref: string, opts: CommonOpts, client?: MemoryClient) => Promise<void>;
-export declare const runWrite: (ref: string, opts: CommonOpts & {
-    body?: string;
-    frontmatter?: string;
-}, client?: MemoryClient) => Promise<void>;
-export declare const runEdit: (ref: string, opts: CommonOpts & {
-    old?: string;
-    new?: string;
-    body?: string;
-    append?: boolean;
-}, client?: MemoryClient) => Promise<void>;
-export declare const runList: (folder: string | undefined, opts: CommonOpts, client?: MemoryClient) => Promise<void>;
-export declare const runDelete: (ref: string, opts: CommonOpts, client?: MemoryClient) => Promise<void>;

package/dist/commands/memory/memory-verbs.js

@@ -1,98 +0,0 @@
-import chalk from 'chalk';
-import { ensureDaemon } from '../../lib/daemon/daemon-client.js';
-import { daemonDisabled } from '../../lib/daemon/daemon-pref.js';
-import { createDirectClient } from '../../lib/memory/memory-client.js';
-import { loadVaultsConfig } from '../../lib/vault/vaults.js';
-// Default engine path (DO3/DO4): the daemon - single writer, autostarted - when reachable; the
-// in-process DirectClient as a seamless fallback (--no-daemon, sandbox/CI, or fork blocked).
-const resolveClient = async () => {
-    const direct = () => createDirectClient(loadVaultsConfig().config);
-    if (daemonDisabled())
-        return direct();
-    const daemon = await ensureDaemon();
-    return daemon ?? direct();
-};
-const readStdin = async () => {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(chunk);
-    return Buffer.concat(chunks).toString('utf-8');
-};
-// --frontmatter must be a JSON object; a raw parser error or a non-object value is unfriendly.
-const parseFrontmatter = (raw) => {
-    if (!raw)
-        return undefined;
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        throw new Error(`--frontmatter must be a JSON object, e.g. '{"tags":["x"]}': ${detail}`);
-    }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
-        throw new Error(`--frontmatter must be a JSON object, e.g. '{"tags":["x"]}'`);
-    return parsed;
-};
-const emit = (json, data, human) => {
-    if (json)
-        console.log(JSON.stringify(data, null, 2));
-    else
-        human();
-};
-// Flatten a folder-tree to the file paths it contains, in tree order.
-const treeFiles = (entries) => entries.flatMap((e) => (e.type === 'file' ? [e.path] : e.entries ? treeFiles(e.entries) : []));
-export const runSearch = async (query, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const out = await c.search(query, {
-        vault: opts.vault,
-        limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
-    });
-    emit(opts.json ?? false, out, () => {
-        if (out.results.length === 0)
-            console.log('No matches.');
-        for (const h of out.results)
-            console.log(`${h.path}\n  ${chalk.gray(h.snippet)}`);
-    });
-};
-export const runRead = async (ref, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const doc = await c.read(ref, { vault: opts.vault });
-    emit(opts.json ?? false, doc, () => console.log(doc.body));
-};
-export const runWrite = async (ref, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const inlineBody = opts.body !== undefined && opts.body !== '-';
-    if (!inlineBody && process.stdin.isTTY)
-        throw new Error('provide --body, or pipe content on stdin');
-    const body = inlineBody ? opts.body : await readStdin();
-    const frontmatter = parseFrontmatter(opts.frontmatter);
-    const out = await c.write(ref, body, { vault: opts.vault, frontmatter });
-    emit(opts.json ?? false, out, () => console.log(chalk.green(`Wrote ${out.path}`)));
-};
-export const runEdit = async (ref, opts, client) => {
-    const c = client ?? (await resolveClient());
-    if (opts.old === undefined && opts.body === undefined)
-        throw new Error('specify --old/--new for a replacement or --body to overwrite');
-    const op = opts.old !== undefined
-        ? { mode: 'str_replace', old_str: opts.old, new_str: opts.new ?? '' }
-        : { mode: opts.append ? 'append' : 'replace', body: opts.body };
-    const out = await c.edit(ref, op, { vault: opts.vault });
-    emit(opts.json ?? false, out, () => console.log(chalk.green(`Edited ${out.path}`)));
-};
-export const runList = async (folder, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const out = await c.list(folder, { vault: opts.vault });
-    emit(opts.json ?? false, out, () => {
-        const files = treeFiles(out.entries);
-        if (files.length === 0)
-            console.log('No documents.');
-        for (const p of files)
-            console.log(p);
-    });
-};
-export const runDelete = async (ref, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const out = await c.delete(ref, { vault: opts.vault });
-    emit(opts.json ?? false, out, () => console.log(`Deleted ${out.path} (recoverable from git history)`));
-};

package/dist/commands/memory/memory.d.ts

@@ -1,2 +0,0 @@
-import { type Command } from 'commander';
-export declare const registerMemory: (program: Command) => void;

package/dist/commands/memory/memory.js

@@ -1,54 +0,0 @@
-import chalk from 'chalk';
-import { translateEngineMessage } from '../../lib/memory/memory-client.js';
-import { runDelete, runEdit, runList, runRead, runSearch, runWrite, } from './memory-verbs.js';
-const guard = (fn) => fn().catch((err) => {
-    const message = translateEngineMessage(err instanceof Error ? err.message : String(err));
-    console.error(chalk.red(message));
-    process.exitCode = 1;
-});
-export const registerMemory = (program) => {
-    const memory = program.command('memory').description('Read + write memory, offline');
-    memory
-        .command('search <query...>')
-        .description('Search a vault (git grep)')
-        .option('--vault <name>', 'target vault')
-        .option('--limit <n>', 'max hits (default 20)')
-        .option('--json', 'machine-readable output')
-        .action((query, opts) => guard(() => runSearch(query.join(' '), opts)));
-    memory
-        .command('read <ref>')
-        .description('Print a document (@<vault>/<path> or <path> --vault)')
-        .option('--vault <name>', 'target vault')
-        .option('--json', 'machine-readable output')
-        .action((ref, opts) => guard(() => runRead(ref, opts)));
-    memory
-        .command('write <ref>')
-        .description('Create or overwrite a document (body from --body or stdin)')
-        .option('--vault <name>', 'target vault')
-        .option('--body <text>', 'document body (omit or "-" to read stdin)')
-        .option('--frontmatter <json>', 'frontmatter as a JSON object')
-        .option('--json', 'machine-readable output')
-        .action((ref, opts) => guard(() => runWrite(ref, opts)));
-    memory
-        .command('edit <ref>')
-        .description('Edit a document: str_replace (--old/--new) or --body (--append)')
-        .option('--vault <name>', 'target vault')
-        .option('--old <str>', 'exact, unique substring to replace')
-        .option('--new <str>', 'replacement (omit to delete the match)')
-        .option('--body <text>', 'replace the whole body')
-        .option('--append', 'append --body instead of replacing')
-        .option('--json', 'machine-readable output')
-        .action((ref, opts) => guard(() => runEdit(ref, opts)));
-    memory
-        .command('list [folder]')
-        .description('List documents in a vault (optionally under a folder)')
-        .option('--vault <name>', 'target vault')
-        .option('--json', 'machine-readable output')
-        .action((folder, opts) => guard(() => runList(folder, opts)));
-    memory
-        .command('delete <ref>')
-        .description('Delete a document (recoverable from git history)')
-        .option('--vault <name>', 'target vault')
-        .option('--json', 'machine-readable output')
-        .action((ref, opts) => guard(() => runDelete(ref, opts)));
-};

package/dist/commands/vault/vault-sync.d.ts

@@ -1,13 +0,0 @@
-import { type VaultsConfig } from '@agentage/memory-core';
-import { type SyncResult } from '../../sync/git/cycle.js';
-import { type SyncTarget } from '../../sync/git/planner.js';
-export interface VaultSyncDeps {
-    loadConfig: () => VaultsConfig;
-    daemonPort: () => Promise<number | null>;
-    runViaDaemon: (port: number, vault: string) => Promise<SyncResult>;
-    runGitInProcess: (target: SyncTarget) => Promise<SyncResult>;
-    log: (msg: string) => void;
-}
-export declare const ACCOUNT_NO_CHANNEL = "not synced - account vaults have no sync channel";
-export declare const runVaultSync: (name: string | undefined, deps: VaultSyncDeps) => Promise<void>;
-export declare const defaultVaultSyncDeps: () => VaultSyncDeps;

package/dist/commands/vault/vault-sync.js

@@ -1,90 +0,0 @@
-import chalk from 'chalk';
-import { isAccountVault } from '@agentage/memory-core';
-import { health, syncRun } from '../../lib/daemon/daemon-client.js';
-import { daemonDisabled } from '../../lib/daemon/daemon-pref.js';
-import { loadVaultsConfig } from '../../lib/vault/vaults.js';
-import { resolvePort } from '../../daemon/lifecycle.js';
-import { runSyncCycle } from '../../sync/git/cycle.js';
-import { syncTargets } from '../../sync/git/planner.js';
-import { redactRemoteUrl } from '../../sync/git/remote-url.js';
-export const ACCOUNT_NO_CHANNEL = 'not synced - account vaults have no sync channel';
-const describeGit = (r) => {
-    if (!r.ok)
-        return chalk.red(`failed (${r.reason ?? 'error'})${r.error ? `: ${r.error}` : ''}`);
-    if (r.skipped)
-        return chalk.yellow(`skipped (${r.skipped})`);
-    const bits = [];
-    if (r.committed)
-        bits.push('committed');
-    if (r.conflicts.length)
-        bits.push(`${r.conflicts.length} conflict copy(ies)`);
-    if (r.pushed)
-        bits.push('pushed');
-    return chalk.green(bits.length ? bits.join(', ') : 'up to date');
-};
-const report = (log, r) => {
-    log(`${r.vault} -> ${redactRemoteUrl(r.remote)}: ${describeGit(r)}`);
-    for (const c of r.conflicts)
-        log(`  kept remote copy: ${c}`);
-};
-// Account vaults whose only origin is the reserved `agentage` remote: nothing syncs them. They are
-// named, never silently skipped, so `vault sync` cannot read as "everything is up to date".
-const unsyncableAccountVaults = (config, gitTargets) => {
-    const git = new Set(gitTargets.map((t) => t.vault));
-    return Object.entries(config.vaults ?? {})
-        .filter(([vault, entry]) => isAccountVault(entry) && !git.has(vault))
-        .map(([vault]) => vault);
-};
-const reportAccounts = (log, vaults) => {
-    for (const vault of vaults)
-        log(`${vault} (account): ${chalk.yellow(ACCOUNT_NO_CHANNEL)}`);
-};
-// `agentage vault sync [name]`: sync one vault (or every syncable vault). Git-origin vaults commit
-// + push + pull-rebase; account (agentage) vaults have no sync channel and are reported as such.
-// Prefers a running daemon (single writer), else runs the cycle in-process. Works for interval-0
-// (manual-only) vaults and with the daemon down. Failures are surfaced, not thrown (V6: never a crash).
-export const runVaultSync = async (name, deps) => {
-    const config = deps.loadConfig();
-    // A named vault that is not registered is an error (mirrors `vault remove`), not a silent no-op.
-    if (name && !(config.vaults ?? {})[name])
-        throw new Error(`vault '${name}' not found`);
-    const gitTargets = syncTargets(config).filter((t) => !name || t.vault === name);
-    const accounts = unsyncableAccountVaults(config, gitTargets).filter((v) => !name || v === name);
-    if (gitTargets.length === 0) {
-        reportAccounts(deps.log, accounts);
-        if (accounts.length === 0)
-            deps.log(name
-                ? `No syncable origin configured for vault '${name}'.`
-                : 'No syncable vaults. Add one with `agentage vault add <name>`.');
-        return;
-    }
-    const vaults = [...new Set(gitTargets.map((t) => t.vault))];
-    deps.log(`Syncing ${vaults.length} vault(s)...`);
-    const port = await deps.daemonPort();
-    if (port !== null) {
-        for (const vault of vaults) {
-            deps.log(`${vault}...`);
-            report(deps.log, await deps.runViaDaemon(port, vault));
-        }
-    }
-    else {
-        for (const target of gitTargets) {
-            deps.log(`${target.vault}...`);
-            report(deps.log, await deps.runGitInProcess(target));
-        }
-    }
-    reportAccounts(deps.log, accounts);
-};
-const resolveDaemonPort = async () => {
-    if (daemonDisabled())
-        return null;
-    const port = resolvePort();
-    return (await health(port)) ? port : null;
-};
-export const defaultVaultSyncDeps = () => ({
-    loadConfig: () => loadVaultsConfig().config,
-    daemonPort: resolveDaemonPort,
-    runViaDaemon: syncRun,
-    runGitInProcess: runSyncCycle,
-    log: (msg) => console.log(msg),
-});