@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/storage/backends/obsidian.js

@@ -0,0 +1,233 @@
+/**
+ * Obsidian Storage Adapter
+ *
+ * Writes and reads markdown files in an Obsidian vault on disk. The
+ * adapter is filesystem-shaped — Obsidian vaults are directories of
+ * `.md` files plus a hidden `.obsidian/` config dir we never touch.
+ *
+ * About the official Obsidian CLI: as of Feb 2026 Obsidian ships an
+ * official CLI for vault interactions. Its primary surface is opening
+ * notes / running commands against a *running* Obsidian instance, not
+ * arbitrary external file writes. Obsidian's own file watcher handles
+ * picking up external markdown changes within a few seconds, so direct
+ * fs writes work cleanly when Obsidian is closed and converge quickly
+ * when it's open.
+ *
+ * What this adapter does:
+ *   - Reads / writes / lists / deletes markdown files via fs
+ *   - Optional CLI reachability probe (when `useCli: true`) — emits a
+ *     one-time warning if the user opted into CLI mode but the
+ *     `obsidian` binary is missing
+ *   - Refuses paths that resolve into the vault's `.obsidian/` config
+ *   - Forwards `WriteMeta.frontmatter` into the markdown's YAML
+ *     frontmatter when provided
+ *   - Does NOT implement `query()` — Obsidian's search is not exposed
+ *     via the CLI as of research date
+ *
+ * @design @.aiwg/architecture/storage-design.md (§5.2)
+ * @issue #934
+ * @issue #957
+ */
+import { existsSync } from 'fs';
+import { mkdir, readFile, readdir, rm, stat, writeFile } from 'fs/promises';
+import { dirname, join, relative, resolve, sep } from 'path';
+import { execSync } from 'child_process';
+const OBSIDIAN_CONFIG_DIR = '.obsidian';
+export class ObsidianAdapter {
+    /** Absolute path to the root the adapter writes into (vault[/folder]). */
+    root;
+    /** Absolute path to the vault — used to enforce the .obsidian/ guard. */
+    vault;
+    useCli;
+    /** Cached result of the CLI reachability probe so we only warn once. */
+    cliWarned = false;
+    constructor(config) {
+        this.vault = resolve(expandHome(config.vault));
+        this.root = config.folder ? join(this.vault, config.folder) : this.vault;
+        this.useCli = config.useCli ?? true;
+    }
+    /**
+     * Validate a subsystem-relative path. Rejects traversal, absolute
+     * paths, backslashes, and any path that resolves into the vault's
+     * `.obsidian/` config directory.
+     */
+    resolveSafe(relPath) {
+        if (typeof relPath !== 'string' || relPath.length === 0) {
+            throw new Error('storage(obsidian): path must be a non-empty string');
+        }
+        if (relPath.includes('\\')) {
+            throw new Error(`storage(obsidian): backslash not allowed in path "${relPath}"`);
+        }
+        if (relPath.startsWith('/') || relPath.startsWith('~')) {
+            throw new Error(`storage(obsidian): absolute paths not allowed: "${relPath}"`);
+        }
+        const segments = relPath.split('/');
+        if (segments.some((s) => s === '..')) {
+            throw new Error(`storage(obsidian): ".." traversal not allowed in "${relPath}"`);
+        }
+        const abs = resolve(this.root, relPath);
+        // Must stay under root
+        if (abs !== this.root && !abs.startsWith(this.root + sep)) {
+            throw new Error(`storage(obsidian): resolved path escapes folder root: "${relPath}"`);
+        }
+        // Must never enter .obsidian/
+        const relFromVault = relative(this.vault, abs);
+        if (relFromVault === OBSIDIAN_CONFIG_DIR ||
+            relFromVault.startsWith(OBSIDIAN_CONFIG_DIR + sep)) {
+            throw new Error(`storage(obsidian): refusing to operate on .obsidian/ vault config (${relPath})`);
+        }
+        return abs;
+    }
+    async init() {
+        if (!existsSync(this.vault)) {
+            throw new Error(`storage(obsidian): vault does not exist: ${this.vault}`);
+        }
+        if (this.useCli)
+            this.probeCli();
+    }
+    /**
+     * One-shot best-effort `obsidian --version` probe. We only warn
+     * (never fail) — direct fs writes still work without the CLI.
+     */
+    probeCli() {
+        if (this.cliWarned)
+            return;
+        try {
+            execSync('obsidian --version', {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: 2000,
+            });
+        }
+        catch {
+            this.cliWarned = true;
+            process.stderr.write(`storage(obsidian): CLI requested (useCli: true) but the \`obsidian\` binary was not found.\n` +
+                `  AIWG will continue with direct file writes against the vault.\n` +
+                `  Set "useCli": false in storage.config to suppress this warning.\n`);
+        }
+    }
+    async read(path) {
+        const abs = this.resolveSafe(path);
+        if (!existsSync(abs))
+            return null;
+        return readFile(abs, 'utf-8');
+    }
+    async write(path, content, meta) {
+        const abs = this.resolveSafe(path);
+        await mkdir(dirname(abs), { recursive: true });
+        // Merge supplied frontmatter into the markdown payload (only when
+        // there isn't already YAML frontmatter at the top — we don't want
+        // to overwrite user-written frontmatter inadvertently).
+        let body = content;
+        if (meta?.frontmatter && Object.keys(meta.frontmatter).length > 0 && !startsWithFrontmatter(content)) {
+            body = renderFrontmatter(meta.frontmatter) + content;
+        }
+        await writeFile(abs, body, 'utf-8');
+    }
+    async list(prefix) {
+        if (typeof prefix !== 'string') {
+            throw new Error('storage(obsidian): list prefix must be a string');
+        }
+        if (prefix.length > 0)
+            this.resolveSafe(prefix);
+        if (!existsSync(this.root))
+            return [];
+        const out = [];
+        await walkInto(this.root, this.root, this.vault, prefix, out);
+        return out;
+    }
+    async delete(path) {
+        const abs = this.resolveSafe(path);
+        if (!existsSync(abs))
+            return;
+        await rm(abs, { force: true });
+    }
+}
+async function walkInto(root, dir, vault, prefix, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        // Skip the vault config directory anywhere under the walk
+        if (e.name === OBSIDIAN_CONFIG_DIR) {
+            const fullForCheck = join(dir, e.name);
+            // Only skip when this is *the* vault's .obsidian/ — a user-created
+            // folder named ".obsidian" inside content would still be skipped
+            // out of paranoia, which matches the safety stance.
+            if (relative(vault, fullForCheck) === OBSIDIAN_CONFIG_DIR)
+                continue;
+            continue; // be conservative: skip any .obsidian directory
+        }
+        const full = join(dir, e.name);
+        const rel = relative(root, full).split(sep).join('/');
+        if (e.isDirectory()) {
+            if (prefix === '' || rel.startsWith(prefix) || prefix.startsWith(rel + '/')) {
+                await walkInto(root, full, vault, prefix, out);
+            }
+            continue;
+        }
+        if (!e.isFile())
+            continue;
+        if (prefix !== '' && !rel.startsWith(prefix))
+            continue;
+        let size;
+        let modifiedAt;
+        try {
+            const s = await stat(full);
+            size = s.size;
+            modifiedAt = s.mtime;
+        }
+        catch {
+            // ignore
+        }
+        const entry = { path: rel };
+        if (size !== undefined)
+            entry.size = size;
+        if (modifiedAt !== undefined)
+            entry.modifiedAt = modifiedAt;
+        out.push(entry);
+    }
+}
+function expandHome(p) {
+    if (p.startsWith('~/')) {
+        const { homedir } = require('os');
+        return join(homedir(), p.slice(2));
+    }
+    if (p === '~') {
+        const { homedir } = require('os');
+        return homedir();
+    }
+    return p;
+}
+function startsWithFrontmatter(content) {
+    // Obsidian frontmatter convention: starts with `---` on a line by itself
+    return /^---\s*\r?\n/.test(content);
+}
+function renderFrontmatter(fm) {
+    const lines = ['---'];
+    for (const [k, v] of Object.entries(fm)) {
+        lines.push(`${k}: ${formatYamlScalar(v)}`);
+    }
+    lines.push('---', '');
+    return lines.join('\n');
+}
+function formatYamlScalar(v) {
+    if (v === null || v === undefined)
+        return '';
+    if (typeof v === 'boolean' || typeof v === 'number')
+        return String(v);
+    if (Array.isArray(v))
+        return '[' + v.map((x) => formatYamlScalar(x)).join(', ') + ']';
+    if (typeof v === 'string') {
+        // Quote strings containing YAML special characters
+        if (/[:\#\n\r\t&*?{}\[\]|>'"%@`!,]/.test(v) || /^\s|\s$/.test(v) || v.length === 0) {
+            return JSON.stringify(v);
+        }
+        return v;
+    }
+    return JSON.stringify(v);
+}
+//# sourceMappingURL=obsidian.js.map

package/dist/src/storage/cli.js

@@ -0,0 +1,468 @@
+/**
+ * Storage CLI — `aiwg storage <subcommand>`
+ *
+ * Subcommands:
+ *   show               — print effective config + resolved physical paths
+ *   list-backends      — inventory of compiled-in adapters with status
+ *   test <subsystem>   — round-trip read/write/list/delete through the
+ *                        configured backend
+ *   migrate <subsystem> — copy entries from one backend to another
+ *
+ * @design @.aiwg/architecture/storage-design.md (§7)
+ * @issue #934
+ * @issue #954
+ * @issue #955
+ */
+import { randomUUID } from 'crypto';
+import { existsSync } from 'fs';
+import { mkdir, readFile, writeFile, appendFile } from 'fs/promises';
+import { dirname, join, resolve as resolvePath } from 'path';
+import { BACKEND_TYPES, FilesystemAdapter, ObsidianAdapter, LogseqAdapter, FortemiAdapter, SUBSYSTEM_KEYS, getLoadedConfig, initStorage, resolveStorage, resolveSubsystemRoot, storageConfigPath, } from './index.js';
+export async function main(args) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    const projectRoot = process.cwd();
+    switch (subcommand) {
+        case 'show':
+            await handleShow(projectRoot);
+            break;
+        case 'list-backends':
+            await handleListBackends(subArgs);
+            break;
+        case 'test':
+            await handleTest(projectRoot, subArgs);
+            break;
+        case 'migrate':
+            await handleMigrate(projectRoot, subArgs);
+            break;
+        default:
+            printUsage();
+            if (subcommand) {
+                throw new Error(`Unknown storage subcommand: ${subcommand}`);
+            }
+    }
+}
+async function handleShow(projectRoot) {
+    await initStorage(projectRoot);
+    const config = await getLoadedConfig(projectRoot);
+    const cfgPath = storageConfigPath(projectRoot);
+    if (!config) {
+        console.log(`No storage.config — every subsystem uses the default fs backend under .aiwg/.\n`);
+        console.log(`Expected location (when configured): ${cfgPath}\n`);
+    }
+    else {
+        console.log(`storage.config: ${cfgPath}`);
+        console.log(`schema version: ${config.version}`);
+        if (config.fallback)
+            console.log(`fallback: ${config.fallback}`);
+        console.log('');
+    }
+    console.log(`Subsystem      Backend       Resolved location`);
+    console.log(`─────────────  ────────────  ──────────────────────────────────────────`);
+    for (const subsystem of SUBSYSTEM_KEYS) {
+        const backend = config?.backends?.[subsystem]?.type ?? 'fs';
+        const location = backend === 'fs'
+            ? resolveSubsystemRoot(subsystem, projectRoot, config)
+            : describeBackendLocation(subsystem, config);
+        const sub = subsystem.padEnd(13);
+        const back = backend.padEnd(12);
+        console.log(`  ${sub}  ${back}  ${location}`);
+    }
+    console.log('');
+}
+async function handleListBackends(args = []) {
+    const json = args.includes('--json');
+    if (json) {
+        const out = BACKEND_TYPES.map((t) => {
+            const status = backendStatus(t);
+            return {
+                type: t,
+                status: status.implemented ? 'ready' : 'stub',
+                note: status.note,
+                ...(status.trackingIssue ? { tracking_issue: status.trackingIssue } : {}),
+            };
+        });
+        console.log(JSON.stringify(out, null, 2));
+        return;
+    }
+    console.log(`Compiled-in storage backends:\n`);
+    console.log(`  STATUS   TYPE          NOTES`);
+    console.log(`  ──────   ────────────  ────────────────────────────────────────`);
+    for (const t of BACKEND_TYPES) {
+        const status = backendStatus(t);
+        const sym = status.implemented ? 'READY ' : 'STUB  ';
+        console.log(`  ${sym}   ${t.padEnd(12)}  ${status.note}`);
+    }
+    console.log('');
+}
+async function handleTest(projectRoot, args) {
+    const subsystem = args[0];
+    if (!subsystem || !SUBSYSTEM_KEYS.includes(subsystem)) {
+        throw new Error(`Usage: aiwg storage test <subsystem>\n` +
+            `  Valid subsystems: ${SUBSYSTEM_KEYS.join(', ')}`);
+    }
+    await initStorage(projectRoot);
+    const adapter = await resolveStorage(subsystem);
+    const probePath = `.aiwg-storage-test/${randomUUID()}.txt`;
+    const probeContent = `aiwg storage test ${subsystem} ${new Date().toISOString()}\n`;
+    let stage = 'init';
+    try {
+        stage = 'write';
+        console.log(`  ► write    ${probePath}`);
+        await adapter.write(probePath, probeContent);
+        stage = 'read';
+        console.log(`  ► read     ${probePath}`);
+        const got = await adapter.read(probePath);
+        if (got !== probeContent) {
+            throw new Error(`read mismatch: expected ${JSON.stringify(probeContent)}, got ${JSON.stringify(got)}`);
+        }
+        stage = 'list';
+        console.log(`  ► list     prefix=.aiwg-storage-test/`);
+        const entries = await adapter.list('.aiwg-storage-test/');
+        if (!entries.some((e) => e.path === probePath)) {
+            throw new Error(`list missing probe path ${probePath}`);
+        }
+        stage = 'delete';
+        console.log(`  ► delete   ${probePath}`);
+        await adapter.delete(probePath);
+        const after = await adapter.read(probePath);
+        if (after !== null) {
+            throw new Error(`delete did not remove ${probePath}`);
+        }
+        console.log(`\n  ✓ all 4 ops succeeded for subsystem "${subsystem}"\n`);
+    }
+    catch (err) {
+        throw new Error(`storage test failed at ${stage}: ${err.message}\n` +
+            `  Subsystem: ${subsystem}\n  Probe path: ${probePath}`);
+    }
+}
+/**
+ * `aiwg storage migrate <subsystem> --from <spec> --to <spec> [--dry-run]`
+ *
+ * Spec format: `<type>:<location>` where type is one of fs/obsidian/
+ * logseq/fortemi and location is:
+ *   fs       → directory path (relative to projectRoot or absolute)
+ *   obsidian → vault directory (folder via `--from-folder`/`--to-folder`)
+ *   logseq   → graph directory
+ *   fortemi  → MCP server name (default: 'fortemi')
+ *
+ * Examples:
+ *   aiwg storage migrate memory --from fs:.aiwg/memory --to obsidian:~/vault --to-folder AIWG/memory
+ *   aiwg storage migrate kb --from fs:.aiwg/kb --to fortemi:fortemi --dry-run
+ *
+ * Walks source.list(''), reads each entry, writes to destination. Tracks
+ * progress in `.aiwg/.storage-cache/migrations/<id>.jsonl` so re-running
+ * resumes from the last successfully-migrated entry.
+ *
+ * @issue #955
+ */
+async function handleMigrate(projectRoot, args) {
+    const opts = parseMigrateArgs(args);
+    const source = buildAdapter(opts.subsystem, opts.from, projectRoot);
+    const destination = buildAdapter(opts.subsystem, opts.to, projectRoot);
+    if (locationsEqual(opts.from, opts.to, projectRoot)) {
+        throw new Error(`Refusing to migrate: source and destination resolve to the same location.\n  ${describeSpec(opts.from)}\n  ${describeSpec(opts.to)}`);
+    }
+    if (source.init)
+        await source.init();
+    if (destination.init)
+        await destination.init();
+    console.log(`storage migrate (${opts.dryRun ? 'DRY RUN' : 'live'})`);
+    console.log(`  subsystem: ${opts.subsystem}`);
+    console.log(`  from:      ${describeSpec(opts.from)}`);
+    console.log(`  to:        ${describeSpec(opts.to)}`);
+    console.log('');
+    const entries = await source.list('');
+    if (entries.length === 0) {
+        console.log('No entries to migrate.');
+        return;
+    }
+    // Resume support: read the per-migration log; skip already-done paths
+    const migrationLogPath = resolvePath(projectRoot, '.aiwg', '.storage-cache', 'migrations', `${opts.subsystem}-${specSlug(opts.from)}-to-${specSlug(opts.to)}.jsonl`);
+    const completed = await readCompletedSet(migrationLogPath);
+    let copied = 0;
+    let skipped = 0;
+    let errored = 0;
+    for (const entry of entries) {
+        if (completed.has(entry.path)) {
+            skipped++;
+            console.log(`  ✓ ${entry.path} (already migrated, skipped)`);
+            continue;
+        }
+        if (opts.dryRun) {
+            copied++;
+            console.log(`  → ${entry.path} (would copy)`);
+            continue;
+        }
+        try {
+            const content = await source.read(entry.path);
+            if (content === null) {
+                errored++;
+                console.log(`  ✗ ${entry.path} (read returned null)`);
+                continue;
+            }
+            await destination.write(entry.path, content);
+            await recordCompletion(migrationLogPath, entry.path);
+            copied++;
+            console.log(`  ✓ ${entry.path}`);
+        }
+        catch (err) {
+            errored++;
+            console.log(`  ✗ ${entry.path} (${err.message})`);
+        }
+    }
+    if (source.close)
+        await source.close();
+    if (destination.close)
+        await destination.close();
+    console.log('');
+    console.log(`Summary: copied=${copied} skipped=${skipped} errored=${errored} total=${entries.length}`);
+    if (!opts.dryRun) {
+        console.log(`Migration log: ${migrationLogPath}`);
+    }
+    if (errored > 0) {
+        throw new Error(`${errored} entr${errored === 1 ? 'y' : 'ies'} failed to migrate.`);
+    }
+}
+function parseMigrateArgs(args) {
+    let subsystem;
+    let from;
+    let to;
+    let fromFolder;
+    let toFolder;
+    let dryRun = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--from')
+            from = args[++i];
+        else if (a === '--to')
+            to = args[++i];
+        else if (a === '--from-folder')
+            fromFolder = args[++i];
+        else if (a === '--to-folder')
+            toFolder = args[++i];
+        else if (a === '--dry-run')
+            dryRun = true;
+        else if (!a.startsWith('--') && !subsystem)
+            subsystem = a;
+        else
+            throw new Error(`Unknown migrate flag: ${a}`);
+    }
+    if (!subsystem || !SUBSYSTEM_KEYS.includes(subsystem)) {
+        throw new Error(`Usage: aiwg storage migrate <subsystem> --from <type>:<location> --to <type>:<location> [--dry-run]\n  Valid subsystems: ${SUBSYSTEM_KEYS.join(', ')}`);
+    }
+    if (!from)
+        throw new Error('storage migrate: --from <type>:<location> is required');
+    if (!to)
+        throw new Error('storage migrate: --to <type>:<location> is required');
+    return {
+        subsystem: subsystem,
+        from: { ...parseSpec(from), ...(fromFolder ? { folder: fromFolder } : {}) },
+        to: { ...parseSpec(to), ...(toFolder ? { folder: toFolder } : {}) },
+        dryRun,
+    };
+}
+function parseSpec(raw) {
+    const idx = raw.indexOf(':');
+    if (idx === -1) {
+        throw new Error(`Invalid backend spec "${raw}" — expected <type>:<location>`);
+    }
+    const type = raw.slice(0, idx);
+    const location = raw.slice(idx + 1);
+    if (!BACKEND_TYPES.includes(type)) {
+        throw new Error(`Unknown backend type "${type}" in spec "${raw}". Valid: ${BACKEND_TYPES.join(', ')}`);
+    }
+    if (location.length === 0) {
+        throw new Error(`Empty location in backend spec "${raw}"`);
+    }
+    return { type: type, location };
+}
+function buildAdapter(subsystem, spec, projectRoot) {
+    switch (spec.type) {
+        case 'fs': {
+            const root = expandFsLocation(spec.location, projectRoot);
+            return new FilesystemAdapter(root);
+        }
+        case 'obsidian':
+            return new ObsidianAdapter({
+                type: 'obsidian',
+                vault: expandFsLocation(spec.location, projectRoot),
+                ...(spec.folder ? { folder: spec.folder } : {}),
+                useCli: false,
+            });
+        case 'logseq':
+            return new LogseqAdapter({
+                type: 'logseq',
+                graph: expandFsLocation(spec.location, projectRoot),
+                useApi: false,
+            });
+        case 'fortemi':
+            return new FortemiAdapter({
+                subsystem,
+                config: { type: 'fortemi', mcpServer: spec.location },
+            });
+        case 'notion':
+        case 'anythingllm':
+        case 's3':
+        case 'webdav':
+            throw new Error(`storage migrate: backend "${spec.type}" not yet implemented. ` +
+                `See issues #959, #960, #962, #963 for tracking.`);
+        default: {
+            const _exhaustive = spec.type;
+            void _exhaustive;
+            throw new Error(`Unhandled backend type ${spec.type}`);
+        }
+    }
+}
+function expandFsLocation(loc, projectRoot) {
+    if (loc.startsWith('~/')) {
+        const { homedir } = require('os');
+        return join(homedir(), loc.slice(2));
+    }
+    if (loc === '~') {
+        const { homedir } = require('os');
+        return homedir();
+    }
+    if (loc.startsWith('/'))
+        return loc;
+    return resolvePath(projectRoot, loc);
+}
+function locationsEqual(a, b, projectRoot) {
+    if (a.type !== b.type)
+        return false;
+    if (a.type === 'fortemi')
+        return a.location === b.location;
+    // For file-shaped backends, compare resolved fs paths
+    return expandFsLocation(a.location, projectRoot) === expandFsLocation(b.location, projectRoot);
+}
+function describeSpec(spec) {
+    return spec.folder ? `${spec.type}:${spec.location} (folder=${spec.folder})` : `${spec.type}:${spec.location}`;
+}
+function specSlug(spec) {
+    return `${spec.type}-${spec.location.replace(/[^a-zA-Z0-9]/g, '_').slice(0, 32)}`;
+}
+async function readCompletedSet(logPath) {
+    if (!existsSync(logPath))
+        return new Set();
+    try {
+        const content = await readFile(logPath, 'utf-8');
+        const out = new Set();
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.path)
+                    out.add(obj.path);
+            }
+            catch {
+                /* ignore malformed line */
+            }
+        }
+        return out;
+    }
+    catch {
+        return new Set();
+    }
+}
+async function recordCompletion(logPath, path) {
+    await mkdir(dirname(logPath), { recursive: true });
+    const line = JSON.stringify({ path, ts: new Date().toISOString() }) + '\n';
+    if (existsSync(logPath)) {
+        await appendFile(logPath, line, 'utf-8');
+    }
+    else {
+        await writeFile(logPath, line, 'utf-8');
+    }
+}
+function describeBackendLocation(subsystem, config) {
+    const b = config?.backends?.[subsystem];
+    if (!b)
+        return '(default fs)';
+    switch (b.type) {
+        case 'obsidian':
+            return `obsidian: ${b.vault}${b.folder ? '/' + b.folder : ''}`;
+        case 'logseq':
+            return `logseq: ${b.graph}${b.useApi === false ? ' (file mode)' : ' (HTTP API)'}`;
+        case 'notion':
+            return `notion: ${'pageId' in b.parent ? 'page=' + b.parent.pageId : 'database=' + b.parent.databaseId}`;
+        case 'anythingllm':
+            return `anythingllm: ${b.baseUrl}/${b.workspace}${b.folder ? '/' + b.folder : ''}`;
+        case 'fortemi':
+            return `fortemi: mcp=${b.mcpServer ?? 'fortemi'}${b.scheme ? ' scheme=' + b.scheme : ''}`;
+        case 's3':
+            return `s3: ${b.bucket}${b.prefix ? '/' + b.prefix : ''}${b.endpoint ? ' @ ' + b.endpoint : ''}`;
+        case 'webdav':
+            return `webdav: ${b.url}`;
+        default:
+            return `(${b.type})`;
+    }
+}
+const ISSUE_TRACKER_BASE = 'https://git.integrolabs.net/roctinam/aiwg/issues';
+export function backendStatus(type) {
+    switch (type) {
+        case 'fs':
+            return { implemented: true, note: 'default backend — local filesystem' };
+        case 'obsidian':
+            return { implemented: true, note: 'fs-shaped vault writes; refuses .obsidian/' };
+        case 'logseq':
+            return { implemented: true, note: 'fs writes; YAML→property:: transform; refuses logseq/' };
+        case 'notion':
+            return {
+                implemented: false,
+                note: 'planned (#959) — REST + external_id upsert',
+                trackingIssue: `${ISSUE_TRACKER_BASE}/959`,
+            };
+        case 'anythingllm':
+            return {
+                implemented: false,
+                note: 'planned (#960) — multipart upload',
+                trackingIssue: `${ISSUE_TRACKER_BASE}/960`,
+            };
+        case 'fortemi':
+            return { implemented: true, note: 'MCP-routed via configured Fortemi server (alpha)' };
+        case 's3':
+            return {
+                implemented: false,
+                note: 'planned (#962) — phase 3',
+                trackingIssue: `${ISSUE_TRACKER_BASE}/962`,
+            };
+        case 'webdav':
+            return {
+                implemented: false,
+                note: 'planned (#963) — phase 3',
+                trackingIssue: `${ISSUE_TRACKER_BASE}/963`,
+            };
+        default: {
+            const _exhaustive = type;
+            void _exhaustive;
+            return { implemented: false, note: 'unknown' };
+        }
+    }
+}
+function printUsage() {
+    console.log(`Usage: aiwg storage <subcommand>
+
+Subcommands:
+  show                          Print effective config + resolved physical paths
+  list-backends [--json]        Inventory of compiled-in adapters; --json emits structured output including tracking_issue URL for stubs
+  test <subsystem>              Round-trip read/write/list/delete through the configured backend
+  migrate <subsystem>           Copy entries from one backend to another (#955)
+    --from <type>:<location>    Source spec (fs:./dir, obsidian:~/vault, logseq:./graph, fortemi:server)
+    --to <type>:<location>      Destination spec (same format)
+    --from-folder <folder>      Optional Obsidian subfolder for source
+    --to-folder <folder>        Optional Obsidian subfolder for destination
+    --dry-run                   Preview operations without writing
+
+Subsystems: ${SUBSYSTEM_KEYS.join(', ')}
+
+Examples:
+  aiwg storage show
+  aiwg storage list-backends
+  aiwg storage test activity_log
+  aiwg storage migrate memory --from fs:.aiwg/memory --to obsidian:~/vault --to-folder AIWG/memory --dry-run
+  aiwg storage migrate kb --from fs:.aiwg/kb --to fortemi:fortemi
+
+See @.aiwg/architecture/storage-design.md for the design.`);
+}
+//# sourceMappingURL=cli.js.map