@jbarket/loomai 0.5.0

package/dist/cli/migrate.js

@@ -0,0 +1,116 @@
+/**
+ * loom migrate — report and apply pending schema migrations to memories.db.
+ *
+ * Exits 0 when all migrations applied or already up to date.
+ * Exits 1 when any migration fails (and prints the error).
+ * Use --dry-run to report pending migrations without applying them.
+ */
+import { parseArgs } from 'node:util';
+import { existsSync } from 'node:fs';
+import BetterSqlite3 from 'better-sqlite3';
+import { runMigrations, pendingMigrations } from '../backends/migrations.js';
+import { resolveSqliteDbPath } from '../config.js';
+import { extractGlobalFlags, resolveEnv } from './args.js';
+import { renderJson } from './io.js';
+const USAGE = `Usage: loom migrate [options]
+
+Report and apply pending schema migrations to memories.db.
+Exits non-zero if any migration fails.
+
+Options:
+  --dry-run          Show pending migrations without applying them
+  --json             Machine-readable output
+  --context-dir <p>  Agent context dir (default: $LOOM_CONTEXT_DIR or ~/.config/loom/default)
+  --help, -h         Show this help
+`;
+export async function run(argv, io) {
+    const { flags: global, rest } = extractGlobalFlags(argv);
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: rest,
+            options: {
+                'dry-run': { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+            },
+            strict: true,
+            allowPositionals: false,
+        });
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n${USAGE}`);
+        return 2;
+    }
+    if (parsed.values.help) {
+        io.stdout(USAGE);
+        return 0;
+    }
+    const env = resolveEnv(global, io.env);
+    const dbPath = resolveSqliteDbPath(env.contextDir);
+    const json = env.json || Boolean(global.json);
+    const dryRun = Boolean(parsed.values['dry-run']);
+    if (!existsSync(dbPath)) {
+        if (json) {
+            renderJson(io, { dbPath, status: 'no_db', migrations: [] });
+        }
+        else {
+            io.stdout(`No memories.db found at ${dbPath} — nothing to migrate.\n`);
+        }
+        return 0;
+    }
+    const db = new BetterSqlite3(dbPath);
+    db.pragma('journal_mode = WAL');
+    try {
+        if (dryRun) {
+            const pending = pendingMigrations(db);
+            if (json) {
+                renderJson(io, {
+                    dbPath,
+                    status: 'dry_run',
+                    pending: pending.map((m) => ({ id: m.id, description: m.description })),
+                });
+            }
+            else if (pending.length === 0) {
+                io.stdout(`memories.db is up to date. No pending migrations.\n`);
+            }
+            else {
+                io.stdout(`Pending migrations (${pending.length}):\n`);
+                for (const m of pending) {
+                    io.stdout(`  - ${m.id}: ${m.description}\n`);
+                }
+            }
+            return 0;
+        }
+        const results = runMigrations(db, { strict: false });
+        const applied = results.filter((r) => r.status === 'applied');
+        const failed = results.filter((r) => r.status === 'failed');
+        if (json) {
+            renderJson(io, {
+                dbPath,
+                status: failed.length > 0 ? 'error' : 'ok',
+                migrations: results,
+            });
+        }
+        else if (failed.length > 0) {
+            for (const r of failed) {
+                io.stderr(`Migration '${r.id}' failed: ${r.error}\n`);
+            }
+            if (applied.length > 0) {
+                io.stdout(`Applied ${applied.length} migration${applied.length === 1 ? '' : 's'} before failure.\n`);
+            }
+        }
+        else if (applied.length === 0) {
+            io.stdout(`memories.db is already up to date.\n`);
+        }
+        else {
+            io.stdout(`Applied ${applied.length} migration${applied.length === 1 ? '' : 's'}:\n`);
+            for (const r of applied) {
+                io.stdout(`  - ${r.id}: ${r.description}\n`);
+            }
+        }
+        return failed.length > 0 ? 1 : 0;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/cli/recall.d.ts

@@ -0,0 +1,2 @@
+import type { IOStreams } from './io.js';
+export declare function run(argv: string[], io: IOStreams): Promise<number>;

package/dist/cli/recall.js

@@ -0,0 +1,91 @@
+/**
+ * loom recall — semantic memory search.
+ */
+import { parseArgs } from 'node:util';
+import { recall } from '../tools/recall.js';
+import { createBackend } from '../backends/index.js';
+import { assertStackVersionCompatible } from '../config.js';
+import { extractGlobalFlags, resolveEnv } from './args.js';
+import { renderJson } from './io.js';
+const USAGE = `Usage: loom recall <query> [options]
+
+Search memories semantically.
+
+Options:
+  --category <name>      Filter by category
+  --project <name>       Filter by project
+  --limit <n>            Max results (default backend-specific)
+  --diversity <f>        MMR diversity 0..1 (default 0.3); 0 = pure relevance order
+  --json                 Emit MemoryMatch[] as JSON
+  --context-dir <path>   Agent context dir
+  --help, -h             Show this help
+`;
+export async function run(argv, io) {
+    const { flags: global, rest } = extractGlobalFlags(argv);
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: rest,
+            options: {
+                category: { type: 'string' },
+                project: { type: 'string' },
+                limit: { type: 'string' },
+                diversity: { type: 'string' },
+                help: { type: 'boolean', short: 'h' },
+            },
+            strict: true,
+            allowPositionals: true,
+        });
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n${USAGE}`);
+        return 2;
+    }
+    if (parsed.values.help) {
+        io.stdout(USAGE);
+        return 0;
+    }
+    const query = parsed.positionals[0];
+    if (!query) {
+        io.stderr(`Missing query.\n${USAGE}`);
+        return 2;
+    }
+    const env = resolveEnv(global, io.env);
+    try {
+        assertStackVersionCompatible(env.contextDir);
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n`);
+        return 1;
+    }
+    const limit = parsed.values.limit !== undefined
+        ? Number.parseInt(parsed.values.limit, 10)
+        : undefined;
+    if (limit !== undefined && (!Number.isInteger(limit) || limit <= 0)) {
+        io.stderr(`--limit must be a positive integer.\n`);
+        return 2;
+    }
+    const diversity = parsed.values.diversity !== undefined
+        ? Number.parseFloat(parsed.values.diversity)
+        : undefined;
+    if (diversity !== undefined && (Number.isNaN(diversity) || diversity < 0 || diversity > 1)) {
+        io.stderr(`--diversity must be between 0 and 1.\n`);
+        return 2;
+    }
+    const input = {
+        query,
+        category: parsed.values.category,
+        project: parsed.values.project,
+        limit,
+        diversity,
+    };
+    if (env.json) {
+        const backend = createBackend(env.contextDir);
+        const matches = await backend.recall(input);
+        renderJson(io, matches);
+        return 0;
+    }
+    const text = await recall(env.contextDir, input);
+    io.stdout(text.endsWith('\n') ? text : text + '\n');
+    return 0;
+}

package/dist/cli/remember.d.ts

@@ -0,0 +1,2 @@
+import type { IOStreams } from './io.js';
+export declare function run(argv: string[], io: IOStreams): Promise<number>;

package/dist/cli/remember.js

@@ -0,0 +1,111 @@
+/**
+ * loom remember — save a new memory. Body from stdin or $EDITOR.
+ */
+import { parseArgs } from 'node:util';
+import { remember } from '../tools/remember.js';
+import { MEMORY_CATEGORIES, isMemoryCategory } from '../categories.js';
+import { assertStackVersionCompatible } from '../config.js';
+import { extractGlobalFlags, resolveEnv } from './args.js';
+import { readBody, renderJson } from './io.js';
+const USAGE = `Usage: loom remember <title> [options]
+
+Body is read from stdin (when piped) or $EDITOR (when interactive).
+
+Options:
+  --category <name>      Category: user|project|self|feedback|reference|pursuit (default: reference)
+  --project <name>       Project tag
+  --ttl <dur>            TTL like "7d", "30d", or "permanent"
+  --refs <csv>           Comma-separated reference refs stored in metadata
+  --meta <json>          JSON object merged into metadata (e.g. '{"where":"voice"}')
+  --json                 Emit MemoryRef
+  --context-dir <path>   Agent context dir
+  --help, -h             Show this help
+`;
+export async function run(argv, io) {
+    const { flags: global, rest } = extractGlobalFlags(argv);
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: rest,
+            options: {
+                category: { type: 'string' },
+                project: { type: 'string' },
+                ttl: { type: 'string' },
+                refs: { type: 'string' },
+                meta: { type: 'string' },
+                help: { type: 'boolean', short: 'h' },
+            },
+            strict: true,
+            allowPositionals: true,
+        });
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n${USAGE}`);
+        return 2;
+    }
+    if (parsed.values.help) {
+        io.stdout(USAGE);
+        return 0;
+    }
+    const title = parsed.positionals[0];
+    if (!title) {
+        io.stderr(`Missing title.\n${USAGE}`);
+        return 2;
+    }
+    const category = parsed.values.category ?? 'reference';
+    if (!isMemoryCategory(category)) {
+        io.stderr(`Unknown category "${category}". Valid categories: ${MEMORY_CATEGORIES.join(', ')}.\n`);
+        return 2;
+    }
+    const env = resolveEnv(global, io.env);
+    try {
+        assertStackVersionCompatible(env.contextDir);
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n`);
+        return 1;
+    }
+    let body;
+    try {
+        body = await readBody(io, 'remember');
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n`);
+        return 1;
+    }
+    if (!body) {
+        io.stderr(`body cannot be empty\n`);
+        return 2;
+    }
+    const refsList = parsed.values.refs
+        ? parsed.values.refs.split(',').map((s) => s.trim()).filter(Boolean)
+        : undefined;
+    let meta;
+    if (parsed.values.meta) {
+        try {
+            const parsedMeta = JSON.parse(parsed.values.meta);
+            if (!parsedMeta || typeof parsedMeta !== 'object' || Array.isArray(parsedMeta))
+                throw new Error('not an object');
+            meta = parsedMeta;
+        }
+        catch (err) {
+            io.stderr(`--meta must be a JSON object: ${err.message}\n`);
+            return 2;
+        }
+    }
+    const metadata = refsList || meta ? { ...(meta ?? {}), ...(refsList ? { refs: refsList } : {}) } : undefined;
+    const ref = await remember(env.contextDir, {
+        category,
+        title,
+        content: body,
+        project: parsed.values.project,
+        ttl: parsed.values.ttl,
+        metadata,
+    });
+    if (env.json) {
+        renderJson(io, ref);
+        return 0;
+    }
+    io.stdout(`Remembered: ${ref.ref} — ${ref.title}\n`);
+    return 0;
+}

package/dist/cli/serve.d.ts

@@ -0,0 +1,2 @@
+import type { IOStreams } from './io.js';
+export declare function run(argv: string[], io: IOStreams): Promise<number>;

package/dist/cli/serve.js

@@ -0,0 +1,71 @@
+/**
+ * loom serve — MCP startup. Default is stdio; `--http` starts the mesh-reachable
+ * HTTP daemon (c-loom-transport) bound to a loopback/mesh interface with an
+ * optional bearer token. Host/port/token come from flags or env:
+ *   --http  --host <h>  --port <n>   (LOOM_HTTP_HOST, LOOM_HTTP_PORT, LOOM_BEARER_TOKEN)
+ * Bind-safety refuses a public/0.0.0.0 host; Tailscale is the access control.
+ */
+import { parseArgs } from 'node:util';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createLoomServer } from '../server.js';
+import { startHttpServer } from '../transport/http-server.js';
+import { resolveContextDir } from '../config.js';
+const USAGE = `Usage: loom serve [options]
+
+Start the MCP server. Default transport is stdio; --http starts the
+mesh-reachable HTTP daemon instead.
+
+Options:
+  --http                 Serve over HTTP instead of stdio
+  --host <h>             HTTP bind host (env LOOM_HTTP_HOST, default 127.0.0.1)
+  --port <n>             HTTP port (env LOOM_HTTP_PORT, default 8787)
+  --help, -h             Show this help
+
+Bearer token comes from LOOM_BEARER_TOKEN. Bind-safety refuses a public host.
+`;
+export async function run(argv, io) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args: argv,
+            options: {
+                http: { type: 'boolean', default: false },
+                host: { type: 'string' },
+                port: { type: 'string' },
+                help: { type: 'boolean', short: 'h' },
+            },
+            strict: true,
+            allowPositionals: true,
+        }));
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n${USAGE}`);
+        return 2;
+    }
+    if (values.help) {
+        io.stdout(USAGE);
+        return 0;
+    }
+    const contextDir = resolveContextDir();
+    if (values.http) {
+        const host = values.host ?? process.env.LOOM_HTTP_HOST ?? '127.0.0.1';
+        const port = Number(values.port ?? process.env.LOOM_HTTP_PORT ?? 8787);
+        const token = process.env.LOOM_BEARER_TOKEN || undefined;
+        const handle = await startHttpServer({ contextDir, host, port, token });
+        io.stderr(`loom: HTTP MCP daemon on http://${handle.host}:${handle.port} ` +
+            `(${token ? 'bearer-gated' : 'open — network is the boundary'})\n`);
+        // Hold open until the process is signalled.
+        await new Promise(() => { });
+        return 0;
+    }
+    const { server } = createLoomServer({ contextDir });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // connect() resolves when the stdio transport STARTS, not when it closes.
+    // Returning here would let the CLI dispatcher process.exit(0) and kill the
+    // server the instant it came up. Hold until the client hangs up.
+    await new Promise((resolve) => {
+        transport.onclose = () => resolve();
+    });
+    return 0;
+}

package/dist/cli/subcommands.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Canonical list of loom CLI subcommands. Shared by the CLI dispatcher
+ * (src/cli/index.ts) and the CLI-vs-MCP routing gate (src/index.ts) so
+ * the set never drifts between entry points.
+ */
+export declare const SUBCOMMANDS: readonly ['wake', 'recall', 'remember', 'forget', 'update', 'memory', 'knowledge', 'update-identity', 'bootstrap', 'serve', 'inject', 'harness', 'install', 'doctor', 'migrate'];
+export type Subcommand = typeof SUBCOMMANDS[number];

package/dist/cli/subcommands.js

@@ -0,0 +1,11 @@
+/**
+ * Canonical list of loom CLI subcommands. Shared by the CLI dispatcher
+ * (src/cli/index.ts) and the CLI-vs-MCP routing gate (src/index.ts) so
+ * the set never drifts between entry points.
+ */
+export const SUBCOMMANDS = [
+    'wake', 'recall', 'remember', 'forget', 'update',
+    'memory', 'knowledge', 'update-identity', 'bootstrap', 'serve',
+    'inject', 'harness',
+    'install', 'doctor', 'migrate',
+];

package/dist/cli/tui/multi-select.d.ts

@@ -0,0 +1,53 @@
+export interface MultiSelectItem<T> {
+    value: T;
+    label: string;
+    detail?: string;
+}
+export interface MultiSelectState<T> {
+    cursor: number;
+    selected: Set<T>;
+}
+export type MultiSelectEvent = {
+    kind: 'up';
+} | {
+    kind: 'down';
+} | {
+    kind: 'toggle';
+} | {
+    kind: 'confirm';
+} | {
+    kind: 'cancel';
+};
+export type MultiSelectResult<T> = {
+    status: 'running';
+    state: MultiSelectState<T>;
+} | {
+    status: 'confirmed';
+    selected: Set<T>;
+} | {
+    status: 'cancelled';
+};
+export interface ReduceOpts {
+    single?: boolean;
+}
+export interface MultiSelectOpts<T> {
+    title: string;
+    items: ReadonlyArray<MultiSelectItem<T>>;
+    initialSelected?: ReadonlySet<T>;
+    single?: boolean;
+}
+export declare function initialState<T>(_items: ReadonlyArray<MultiSelectItem<T>>, initialSelected?: ReadonlySet<T>): MultiSelectState<T>;
+export declare function reduce<T>(state: MultiSelectState<T>, event: MultiSelectEvent, items: ReadonlyArray<MultiSelectItem<T>>, opts?: ReduceOpts): MultiSelectResult<T>;
+interface KeypressAdapterDeps {
+    stdin: NodeJS.ReadStream;
+    stdout: {
+        write: (s: string) => void;
+    };
+}
+/**
+ * TTY wrapper around `reduce`. Returns the confirmed selection or null
+ * on cancel. Throws if stdin is not a TTY — callers must check
+ * beforehand.
+ */
+export declare function multiSelect<T>(opts: MultiSelectOpts<T>, deps?: KeypressAdapterDeps): Promise<ReadonlySet<T> | null>;
+export {};

package/dist/cli/tui/multi-select.js

@@ -0,0 +1,116 @@
+/**
+/**
+ * Reusable keyboard-nav multi-select primitive. The reducer is pure and
+ * fully unit-tested; the TTY adapter (`multiSelect`) is a thin
+ * stdin+render wrapper exercised by the inject integration test and
+ * manual verification only. Raw-mode stdin + ANSI cursor codes.
+ */
+import { emitKeypressEvents } from 'node:readline';
+export function initialState(_items, initialSelected) {
+    return {
+        cursor: 0,
+        selected: new Set(initialSelected ?? []),
+    };
+}
+export function reduce(state, event, items, opts = {}) {
+    switch (event.kind) {
+        case 'up': {
+            if (items.length === 0)
+                return { status: 'running', state };
+            const cursor = (state.cursor - 1 + items.length) % items.length;
+            return { status: 'running', state: { ...state, cursor } };
+        }
+        case 'down': {
+            if (items.length === 0)
+                return { status: 'running', state };
+            const cursor = (state.cursor + 1) % items.length;
+            return { status: 'running', state: { ...state, cursor } };
+        }
+        case 'toggle': {
+            if (items.length === 0)
+                return { status: 'running', state };
+            const v = items[state.cursor].value;
+            const has = state.selected.has(v);
+            let next;
+            if (opts.single) {
+                next = has ? new Set() : new Set([v]);
+            }
+            else {
+                next = new Set(state.selected);
+                if (has)
+                    next.delete(v);
+                else
+                    next.add(v);
+            }
+            return { status: 'running', state: { cursor: state.cursor, selected: next } };
+        }
+        case 'confirm':
+            return { status: 'confirmed', selected: new Set(state.selected) };
+        case 'cancel':
+            return { status: 'cancelled' };
+    }
+}
+// ─── TTY adapter (manually verified) ────────────────────────────────────────
+function renderFrame(opts, state, write) {
+    // Clear screen + move home; keep scrollback.
+    write('\x1b[2J\x1b[H');
+    write(`${opts.title}\n\n`);
+    opts.items.forEach((item, i) => {
+        const marker = state.selected.has(item.value) ? '[x]' : '[ ]';
+        const pointer = i === state.cursor ? '›' : ' ';
+        const detail = item.detail ? `  ${item.detail}` : '';
+        write(`  ${pointer} ${marker} ${item.label}${detail}\n`);
+    });
+    const hint = opts.single
+        ? '\n  ↑/↓ move    space select    enter confirm    esc/q cancel\n'
+        : '\n  ↑/↓ move    space toggle    enter confirm    esc/q cancel\n';
+    write(hint);
+}
+/**
+ * TTY wrapper around `reduce`. Returns the confirmed selection or null
+ * on cancel. Throws if stdin is not a TTY — callers must check
+ * beforehand.
+ */
+export async function multiSelect(opts, deps = { stdin: process.stdin, stdout: process.stdout }) {
+    const { stdin, stdout } = deps;
+    if (!stdin.isTTY) {
+        throw new Error('multiSelect requires a TTY stdin');
+    }
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    let state = initialState(opts.items, opts.initialSelected);
+    const write = (s) => stdout.write(s);
+    renderFrame(opts, state, write);
+    return new Promise((resolve) => {
+        const onKey = (_str, key) => {
+            let event = null;
+            if (key.ctrl && key.name === 'c')
+                event = { kind: 'cancel' };
+            else if (key.name === 'escape' || key.name === 'q')
+                event = { kind: 'cancel' };
+            else if (key.name === 'up')
+                event = { kind: 'up' };
+            else if (key.name === 'down')
+                event = { kind: 'down' };
+            else if (key.name === 'space')
+                event = { kind: 'toggle' };
+            else if (key.name === 'return')
+                event = { kind: 'confirm' };
+            if (!event)
+                return;
+            const result = reduce(state, event, opts.items, { single: opts.single });
+            if (result.status === 'running') {
+                state = result.state;
+                renderFrame(opts, state, write);
+                return;
+            }
+            stdin.off('keypress', onKey);
+            stdin.setRawMode(false);
+            stdin.pause();
+            write('\n');
+            resolve(result.status === 'confirmed' ? result.selected : null);
+        };
+        stdin.on('keypress', onKey);
+    });
+}

package/dist/cli/update-identity.d.ts

@@ -0,0 +1,2 @@
+import type { IOStreams } from './io.js';
+export declare function run(argv: string[], io: IOStreams): Promise<number>;

package/dist/cli/update-identity.js

@@ -0,0 +1,90 @@
+/**
+ * loom update-identity — list sections or replace/append section body.
+ */
+import { parseArgs } from 'node:util';
+import { listSections, updateIdentity } from '../tools/update-identity.js';
+import { assertStackVersionCompatible } from '../config.js';
+import { extractGlobalFlags, resolveEnv } from './args.js';
+import { readBody, renderJson } from './io.js';
+const USAGE = `Usage:
+  loom update-identity <file>                  # list sections (read-only)
+  loom update-identity <file> <section>        # replace section body
+  loom update-identity <file> <section> --append  # add as new section
+
+<file> is "preferences" or "self-model". IDENTITY.md is immutable.
+
+Body (for replace/append) is read from stdin or \$EDITOR.
+
+Options:
+  --append               Add a new H2 section at end instead of replacing
+  --json                 Emit {file, section, mode} on success
+  --context-dir <path>   Agent context dir
+  --help, -h             Show this help
+`;
+const EDITABLE = new Set(['preferences', 'self-model']);
+export async function run(argv, io) {
+    const { flags: global, rest } = extractGlobalFlags(argv);
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: rest,
+            options: {
+                append: { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+            },
+            strict: true,
+            allowPositionals: true,
+        });
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n${USAGE}`);
+        return 2;
+    }
+    if (parsed.values.help) {
+        io.stdout(USAGE);
+        return 0;
+    }
+    const file = parsed.positionals[0];
+    const section = parsed.positionals[1];
+    if (!file) {
+        io.stderr(`Missing <file>.\n${USAGE}`);
+        return 2;
+    }
+    if (!EDITABLE.has(file)) {
+        io.stderr(`Unknown file "${file}". Editable: preferences, self-model.\n`);
+        return 2;
+    }
+    const env = resolveEnv(global, io.env);
+    try {
+        assertStackVersionCompatible(env.contextDir);
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n`);
+        return 1;
+    }
+    if (!section) {
+        const text = await listSections(env.contextDir, file);
+        io.stdout(text.endsWith('\n') ? text : text + '\n');
+        return 0;
+    }
+    let body;
+    try {
+        body = await readBody(io, 'update-identity');
+    }
+    catch (err) {
+        io.stderr(`${err.message}\n`);
+        return 1;
+    }
+    if (!body) {
+        io.stderr(`body cannot be empty\n`);
+        return 2;
+    }
+    const mode = parsed.values.append ? 'append' : 'replace';
+    await updateIdentity(env.contextDir, { file, section, content: body, mode });
+    if (env.json) {
+        renderJson(io, { file, section, mode });
+        return 0;
+    }
+    io.stdout(`${mode === 'append' ? 'Appended' : 'Replaced'} ${file}:${section}\n`);
+    return 0;
+}