gnosys 5.11.3 → 5.12.0

package/dist/lib/setupRemotePullCommand.js

@@ -0,0 +1,52 @@
+import { GnosysDB } from "./db.js";
+export async function runSetupRemotePullCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openLocal();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const remotePath = centralDb.getMeta("remote_path");
+        if (!remotePath) {
+            console.error("Remote not configured.");
+            process.exitCode = 1;
+            return;
+        }
+        const { RemoteSync: RemoteSyncCtor } = await import("./remote.js");
+        const { withHeartbeat } = await import("./heartbeat.js");
+        const { createProgress } = await import("./progress.js");
+        const progress = createProgress(!!opts.verbose);
+        let sync = null;
+        try {
+            sync = new RemoteSyncCtor(centralDb, remotePath);
+            const runPull = () => sync.pull({
+                strategy: opts.newerWins ? "newer-wins" : "skip-and-flag",
+                onProgress: progress.noop ? undefined : progress.emit.bind(progress),
+            });
+            const result = opts.verbose
+                ? await runPull()
+                : await withHeartbeat("Pulling from remote", runPull);
+            const projParts = (result.projectsPulled || 0) > 0 ? ` | Projects pulled: ${result.projectsPulled}` : "";
+            const auditParts = (result.auditPulled || 0) > 0 ? ` | Audit pulled: ${result.auditPulled}` : "";
+            console.log(`Pulled: ${result.pulled} | Skipped: ${result.skipped} | Conflicts: ${result.conflicts.length}${projParts}${auditParts}`);
+            if (result.errors.length > 0) {
+                console.log("\nErrors:");
+                for (const e of result.errors)
+                    console.log(`  ${e}`);
+            }
+        }
+        finally {
+            sync?.closeRemote();
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/setupRemotePushCommand.d.ts

@@ -0,0 +1,5 @@
+export type SetupRemotePushCommandOptions = {
+    newerWins?: boolean;
+    verbose?: boolean;
+};
+export declare function runSetupRemotePushCommand(opts: SetupRemotePushCommandOptions): Promise<void>;

package/dist/lib/setupRemotePushCommand.js

@@ -0,0 +1,57 @@
+import { GnosysDB } from "./db.js";
+export async function runSetupRemotePushCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openLocal();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const remotePath = centralDb.getMeta("remote_path");
+        if (!remotePath) {
+            console.error("Remote not configured.");
+            process.exitCode = 1;
+            return;
+        }
+        const { RemoteSync: RemoteSyncCtor } = await import("./remote.js");
+        const { withHeartbeat } = await import("./heartbeat.js");
+        const { createProgress } = await import("./progress.js");
+        const progress = createProgress(!!opts.verbose);
+        let sync = null;
+        try {
+            sync = new RemoteSyncCtor(centralDb, remotePath);
+            const runPush = () => sync.push({
+                strategy: opts.newerWins ? "newer-wins" : "skip-and-flag",
+                onProgress: progress.noop ? undefined : progress.emit.bind(progress),
+            });
+            const result = opts.verbose
+                ? await runPush()
+                : await withHeartbeat("Pushing to remote", runPush);
+            const projParts = (result.projectsPushed || 0) > 0 ? ` | Projects pushed: ${result.projectsPushed}` : "";
+            const auditParts = (result.auditPushed || 0) > 0 ? ` | Audit pushed: ${result.auditPushed}` : "";
+            console.log(`Pushed: ${result.pushed} | Skipped: ${result.skipped} | Conflicts: ${result.conflicts.length}${projParts}${auditParts}`);
+            if (result.errors.length > 0) {
+                console.log("\nErrors:");
+                for (const e of result.errors)
+                    console.log(`  ${e}`);
+            }
+            if (result.conflicts.length > 0) {
+                console.log("\nConflicts flagged (run 'gnosys setup remote status' for details):");
+                for (const c of result.conflicts)
+                    console.log(`  ${c.memoryId} — ${c.title}`);
+            }
+        }
+        finally {
+            sync?.closeRemote();
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/setupRemoteResolveCommand.d.ts

@@ -0,0 +1,4 @@
+export type SetupRemoteResolveCommandOptions = {
+    keep: string;
+};
+export declare function runSetupRemoteResolveCommand(memoryId: string, opts: SetupRemoteResolveCommandOptions): Promise<void>;

package/dist/lib/setupRemoteResolveCommand.js

@@ -0,0 +1,48 @@
+import { GnosysDB } from "./db.js";
+export async function runSetupRemoteResolveCommand(memoryId, opts) {
+    if (opts.keep !== "local" && opts.keep !== "remote") {
+        console.error(`--keep must be 'local' or 'remote' (got: ${opts.keep})`);
+        process.exitCode = 1;
+        return;
+    }
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openLocal();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const remotePath = centralDb.getMeta("remote_path");
+        if (!remotePath) {
+            console.error("Remote not configured.");
+            process.exitCode = 1;
+            return;
+        }
+        const { RemoteSync: RemoteSyncCtor } = await import("./remote.js");
+        let sync = null;
+        try {
+            sync = new RemoteSyncCtor(centralDb, remotePath);
+            const result = await sync.resolve(memoryId, opts.keep);
+            if (result.ok) {
+                console.log(`Resolved ${memoryId}: kept ${opts.keep} version.`);
+            }
+            else {
+                console.error(`Failed to resolve: ${result.error}`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        finally {
+            sync?.closeRemote();
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/setupRemoteStatusCommand.d.ts

@@ -0,0 +1,4 @@
+export type SetupRemoteStatusCommandOptions = {
+    json?: boolean;
+};
+export declare function runSetupRemoteStatusCommand(opts: SetupRemoteStatusCommandOptions): Promise<void>;

package/dist/lib/setupRemoteStatusCommand.js

@@ -0,0 +1,73 @@
+import { GnosysDB } from "./db.js";
+export async function runSetupRemoteStatusCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openLocal();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const { getConfiguredRemotePath } = await import("./remote.js");
+        const remotePath = getConfiguredRemotePath(centralDb);
+        if (!remotePath) {
+            if (opts.json) {
+                console.log(JSON.stringify({ configured: false, message: "Remote not configured. Run 'gnosys setup remote'." }, null, 2));
+            }
+            else {
+                console.log("Remote sync: not configured.");
+                console.log("Run 'gnosys setup remote' to set up multi-machine sync.");
+            }
+            return;
+        }
+        const mc = (await import("./machineConfig.js")).readMachineConfig();
+        if (mc?.remote.role) {
+            const { getV13SyncStatus } = await import("./syncClient.js");
+            const v13 = getV13SyncStatus(centralDb);
+            if (opts.json) {
+                console.log(JSON.stringify(v13, null, 2));
+            }
+            else {
+                console.log(`Multi-machine sync (${v13.role}) — ${v13.masterPath}`);
+                for (const line of v13.lines)
+                    console.log(line);
+                if (v13.snapshotAge)
+                    console.log(`Snapshot as of ${v13.snapshotAge}`);
+            }
+            return;
+        }
+        const { RemoteSync: RemoteSyncCtor, formatStatus } = await import("./remote.js");
+        const { withHeartbeat } = await import("./heartbeat.js");
+        let sync = null;
+        try {
+            sync = new RemoteSyncCtor(centralDb, remotePath);
+            const status = await withHeartbeat("Checking remote sync status", () => sync.getStatus());
+            if (opts.json) {
+                console.log(JSON.stringify(status, null, 2));
+            }
+            else {
+                console.log(formatStatus(status));
+                if (status.conflicts.length > 0) {
+                    console.log("\nConflicts:");
+                    for (const c of status.conflicts) {
+                        console.log(`  ${c.memoryId}: ${c.title}`);
+                        console.log(`    local:  ${c.localModified}`);
+                        console.log(`    remote: ${c.remoteModified}`);
+                    }
+                    console.log("\nResolve with: gnosys setup remote resolve <memory-id> --keep <local|remote>");
+                }
+            }
+        }
+        finally {
+            sync?.closeRemote();
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/setupRemoteSyncCommand.d.ts

@@ -0,0 +1,6 @@
+export type SetupRemoteSyncCommandOptions = {
+    auto?: boolean;
+    newerWins?: boolean;
+    verbose?: boolean;
+};
+export declare function runSetupRemoteSyncCommand(opts: SetupRemoteSyncCommandOptions): Promise<void>;

package/dist/lib/setupRemoteSyncCommand.js

@@ -0,0 +1,65 @@
+import { GnosysDB } from "./db.js";
+export async function runSetupRemoteSyncCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openLocal();
+        if (!centralDb.isAvailable()) {
+            if (!opts.auto)
+                console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const remotePath = centralDb.getMeta("remote_path");
+        if (!remotePath) {
+            if (!opts.auto)
+                console.error("Remote not configured.");
+            process.exitCode = opts.auto ? 0 : 1;
+            return;
+        }
+        const { RemoteSync: RemoteSyncCtor } = await import("./remote.js");
+        const { withHeartbeat } = await import("./heartbeat.js");
+        const { createProgress } = await import("./progress.js");
+        const progress = createProgress(!!opts.verbose);
+        let sync = null;
+        try {
+            sync = new RemoteSyncCtor(centralDb, remotePath);
+            const runSync = () => sync.sync({
+                auto: opts.auto,
+                strategy: opts.newerWins ? "newer-wins" : "skip-and-flag",
+                onProgress: progress.noop ? undefined : progress.emit.bind(progress),
+            });
+            const result = opts.auto || opts.verbose
+                ? await runSync()
+                : await withHeartbeat("Syncing with remote", runSync);
+            if (!opts.auto || result.conflicts.length > 0 || result.errors.length > 0) {
+                const pp = result.projectsPushed || 0;
+                const pl = result.projectsPulled || 0;
+                const ap = result.auditPushed || 0;
+                const al = result.auditPulled || 0;
+                const projParts = pp + pl > 0 ? ` | Projects: ↑${pp}/↓${pl}` : "";
+                const auditParts = ap + al > 0 ? ` | Audit: ↑${ap}/↓${al}` : "";
+                console.log(`Pushed: ${result.pushed} | Pulled: ${result.pulled} | Conflicts: ${result.conflicts.length}${projParts}${auditParts}`);
+                if (result.errors.length > 0) {
+                    console.log("\nErrors:");
+                    for (const e of result.errors)
+                        console.log(`  ${e}`);
+                }
+                if (result.conflicts.length > 0) {
+                    console.log("\nConflicts need resolution (run 'gnosys setup remote status' for details).");
+                }
+            }
+        }
+        finally {
+            sync?.closeRemote();
+        }
+    }
+    catch (err) {
+        if (!opts.auto)
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/setupSyncProjectsCommand.d.ts

@@ -0,0 +1,4 @@
+export type SetupSyncProjectsCommandOptions = {
+    skipDashboard?: boolean;
+};
+export declare function runSetupSyncProjectsCommand(opts: SetupSyncProjectsCommandOptions): Promise<void>;

package/dist/lib/setupSyncProjectsCommand.js

@@ -0,0 +1,292 @@
+import path from "path";
+import fs from "fs/promises";
+import os from "os";
+import { fileURLToPath } from "url";
+import { GnosysDB } from "./db.js";
+import { GnosysResolver } from "./resolver.js";
+import { createProjectIdentity } from "./projectIdentity.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+async function packageVersion() {
+    const pkgPath = path.resolve(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+    return pkg.version;
+}
+export async function runSetupSyncProjectsCommand(opts) {
+    const currentVersion = await packageVersion();
+    // v5.9.3 Screen 10 — Header + leading spinner + hierarchical sections.
+    const { renderSyncHeader, renderUpgradedSection, renderSkippedSection, renderFailedSection, renderMachinesSection, renderDivider, renderDoneLine, renderDashboardSummary, } = await import("./setup/syncProjectsRender.js");
+    const { Spinner } = await import("./setup/ui/spinner.js");
+    console.log("");
+    console.log(renderSyncHeader(currentVersion));
+    console.log("");
+    // 1. Read registered projects from file registry AND central DB
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    const registryPath = path.join(home, ".config", "gnosys", "projects.json");
+    let fileProjects = [];
+    try {
+        fileProjects = JSON.parse(await fs.readFile(registryPath, "utf-8"));
+    }
+    catch {
+        // No file registry yet
+    }
+    // Also check central DB for projects not in the file registry. Also
+    // capture project titles so the Screen 10 row labels can use the
+    // human-readable name where available.
+    let dbProjects = [];
+    const titleByDir = new Map();
+    try {
+        const centralDb = GnosysDB.openCentral();
+        if (centralDb.isAvailable()) {
+            const allProjects = centralDb.getAllProjects();
+            dbProjects = allProjects.map((p) => p.working_directory);
+            for (const p of allProjects)
+                titleByDir.set(p.working_directory, p.name);
+            centralDb.close();
+        }
+    }
+    catch {
+        // non-critical
+    }
+    // Merge: deduplicate by resolved path
+    const seen = new Set();
+    const projects = [];
+    for (const p of [...fileProjects, ...dbProjects]) {
+        const resolved = path.resolve(p);
+        if (!seen.has(resolved)) {
+            seen.add(resolved);
+            projects.push(resolved);
+        }
+    }
+    if (projects.length === 0) {
+        console.log(" no registered projects found");
+        console.log(" run `gnosys init` in each project first");
+        return;
+    }
+    // Lead-in spinner: shows we're churning through the registry. Resolves
+    // to ✓ summary after the iteration loop completes (or fail on hard error).
+    const syncSpinner = Spinner(`syncing ${projects.length} registered projects…`);
+    // Sync the merged list back to file registry
+    try {
+        await fs.mkdir(path.dirname(registryPath), { recursive: true });
+        await fs.writeFile(registryPath, JSON.stringify(projects, null, 2), "utf-8");
+    }
+    catch {
+        // non-critical
+    }
+    // 2. Iterate and upgrade each project that exists on this machine
+    const upgraded = [];
+    const skipped = [];
+    const failed = [];
+    for (const projectDir of projects) {
+        // Skip test/temp directories
+        if (projectDir.startsWith("/tmp/") || projectDir.startsWith("/private/tmp/") || projectDir.startsWith("/var/folders/") || projectDir.startsWith("/private/var/folders/")) {
+            continue;
+        }
+        const storePath = path.join(projectDir, ".gnosys");
+        try {
+            await fs.stat(storePath);
+        }
+        catch {
+            skipped.push(projectDir);
+            continue;
+        }
+        try {
+            // Re-create project identity (re-syncs with central DB)
+            let centralDb = null;
+            try {
+                centralDb = GnosysDB.openCentral();
+                if (!centralDb.isAvailable())
+                    centralDb = null;
+            }
+            catch {
+                centralDb = null;
+            }
+            await createProjectIdentity(projectDir, { centralDb: centralDb || undefined });
+            // Re-register in file-based registry (idempotent)
+            const tempResolver = new GnosysResolver();
+            await tempResolver.registerProject(projectDir);
+            // Re-generate agent rules for all detected IDEs
+            if (centralDb) {
+                const { syncToTarget } = await import("./rulesGen.js");
+                const { readProjectIdentity } = await import("./projectIdentity.js");
+                const identity = await readProjectIdentity(projectDir);
+                const projectId = identity?.projectId || null;
+                try {
+                    await syncToTarget(centralDb, projectDir, "all", projectId);
+                }
+                catch {
+                    // Some projects may not have IDE configs — that's ok
+                }
+                centralDb.close();
+            }
+            // Configure IDE hooks for automatic memory recall
+            const { configureIdeHooks } = await import("./projectIdentity.js");
+            await configureIdeHooks(projectDir);
+            upgraded.push(projectDir);
+        }
+        catch (err) {
+            failed.push(`${projectDir} (${err.message})`);
+        }
+    }
+    // Stop the lead-in spinner now that the iteration is done. Resolved
+    // before any per-section output so the cursor is on a fresh line.
+    syncSpinner.ok(`synced ${projects.length} registered projects`, `${upgraded.length} upgraded · ${skipped.length} skipped · ${failed.length} failed`);
+    // 3. Update global agent rules
+    try {
+        let centralDb = null;
+        try {
+            centralDb = GnosysDB.openCentral();
+            if (!centralDb.isAvailable())
+                centralDb = null;
+        }
+        catch {
+            centralDb = null;
+        }
+        if (centralDb) {
+            const { syncToTarget } = await import("./rulesGen.js");
+            await syncToTarget(centralDb, process.cwd(), "global", null);
+            centralDb.close();
+            const { printStatus } = await import("./setup/ui/status.js");
+            printStatus("ok", "global agent rules updated", "~/.claude/CLAUDE.md");
+        }
+    }
+    catch {
+        const { printStatus } = await import("./setup/ui/status.js");
+        printStatus("warn", "could not update global agent rules");
+    }
+    // 4. Stamp the central DB with current version and machine info
+    try {
+        const centralDb = GnosysDB.openCentral();
+        if (centralDb.isAvailable()) {
+            const hostname = os.hostname();
+            centralDb.setMeta("app_version", currentVersion);
+            centralDb.setMeta("last_upgrade", new Date().toISOString());
+            centralDb.setMeta("upgraded_by", hostname);
+            // Record this machine in the connected-machines registry. Keyed by
+            // hostname, but we pass machineId + any previous hostnames so a renamed
+            // machine prunes its own orphaned entry instead of showing up twice.
+            const { ensureMachineConfig } = await import("./machineConfig.js");
+            const { recordMachine } = await import("./machineRegistry.js");
+            const machine = ensureMachineConfig().config;
+            recordMachine(centralDb, {
+                hostname,
+                version: currentVersion,
+                machineId: machine.machineId,
+                aliases: machine.previousHostnames,
+            });
+            centralDb.close();
+        }
+    }
+    catch {
+        // non-critical
+    }
+    // 5. Report — v5.9.3 Screen 10 hierarchical layout. Section helpers
+    // turn the raw path arrays into ProjectRow lists (title + fullPath)
+    // and emit dividers between groups.
+    function rowFor(p) {
+        const title = titleByDir.get(p) ?? titleByDir.get(path.resolve(p)) ?? path.basename(p);
+        return { title, fullPath: p };
+    }
+    const upgradedRows = upgraded.map(rowFor);
+    const skippedRows = skipped.map(rowFor);
+    const failedRows = failed.map((f) => {
+        // failed entries are "<path> (<err>)" — extract path for the title.
+        const match = f.match(/^(.+?)\s\((.+)\)$/);
+        const projectPath = match ? match[1] : f;
+        return { title: titleByDir.get(projectPath) ?? path.basename(projectPath), fullPath: f };
+    });
+    console.log("");
+    for (const line of renderUpgradedSection(upgradedRows))
+        console.log(line);
+    if (upgradedRows.length > 0 && (skippedRows.length > 0 || failedRows.length > 0)) {
+        console.log("");
+    }
+    for (const line of renderSkippedSection(skippedRows))
+        console.log(line);
+    if (failedRows.length > 0) {
+        console.log("");
+        for (const line of renderFailedSection(failedRows))
+            console.log(line);
+    }
+    // Connected-machines callout (separate divider per design spec).
+    let machineLines = [];
+    try {
+        const centralDb = GnosysDB.openCentral();
+        if (centralDb.isAvailable()) {
+            const { readMachineRegistry } = await import("./machineRegistry.js");
+            const machines = readMachineRegistry(centralDb);
+            const entries = Object.entries(machines);
+            if (entries.length > 0) {
+                const currentHost = os.hostname();
+                const machineRows = entries.map(([host, info]) => ({
+                    hostname: host,
+                    version: info.version,
+                    lastSeen: info.lastSeen,
+                    isCurrent: host === currentHost,
+                }));
+                machineLines = renderMachinesSection(machineRows, currentVersion);
+            }
+            centralDb.close();
+        }
+    }
+    catch {
+        // non-critical
+    }
+    if (machineLines.length > 0) {
+        console.log("");
+        console.log(renderDivider());
+        console.log("");
+        for (const line of machineLines)
+            console.log(line);
+    }
+    console.log("");
+    console.log(renderDivider());
+    console.log("");
+    console.log(renderDoneLine(currentVersion));
+    if (skippedRows.length > 0) {
+        // v5.9.3 Phase H: offer one-keystroke cleanup. Stays interactive
+        // by default; users on a TTY get the prompt, non-TTY runs silently
+        // (sync-projects is sometimes invoked from CI).
+        console.log("");
+        if (process.stdout.isTTY) {
+            try {
+                const { cleanupRegistry } = await import("./cleanup.js");
+                await cleanupRegistry({ interactive: true });
+            }
+            catch (err) {
+                const { printStatus } = await import("./setup/ui/status.js");
+                printStatus("warn", "cleanup skipped", err instanceof Error ? err.message : String(err));
+            }
+        }
+        else {
+            const { printStatus } = await import("./setup/ui/status.js");
+            printStatus("progress", "tip", "run `gnosys cleanup` to remove stale entries");
+        }
+    }
+    // 6. Regenerate portfolio dashboard
+    if (!opts.skipDashboard) {
+        try {
+            const dashboardPath = path.join(home, "gnosys-dashboard.html");
+            const dashboardMdPath = path.join(home, "gnosys-dashboard.md");
+            const centralDb = GnosysDB.openCentral();
+            if (centralDb.isAvailable()) {
+                const { generatePortfolio, formatPortfolioMarkdown } = await import("./portfolio.js");
+                const { generatePortfolioHtml } = await import("./portfolioHtml.js");
+                const report = generatePortfolio(centralDb);
+                await fs.writeFile(dashboardPath, generatePortfolioHtml(report, dashboardPath), "utf-8");
+                await fs.writeFile(dashboardMdPath, formatPortfolioMarkdown(report), "utf-8");
+                centralDb.close();
+                console.log("");
+                for (const line of renderDashboardSummary(dashboardPath, dashboardMdPath)) {
+                    console.log(line);
+                }
+            }
+        }
+        catch {
+            const { printStatus } = await import("./setup/ui/status.js");
+            console.log("");
+            printStatus("warn", "could not regenerate portfolio dashboard");
+        }
+    }
+}

package/dist/lib/staleCommand.d.ts

@@ -0,0 +1,8 @@
+import type { GnosysResolver } from "./resolver.js";
+export type StaleCommandOptions = {
+    days: string;
+    limit: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runStaleCommand(getResolver: GetResolver, opts: StaleCommandOptions): Promise<void>;
+export {};

package/dist/lib/staleCommand.js

@@ -0,0 +1,34 @@
+export async function runStaleCommand(getResolver, opts) {
+    const resolver = await getResolver();
+    const threshold = parseInt(opts.days);
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - threshold);
+    const cutoffStr = cutoff.toISOString().split("T")[0];
+    const allMemories = await resolver.getAllMemories();
+    const stale = allMemories
+        .filter((m) => {
+        const lastTouched = m.frontmatter.last_reviewed ||
+            m.frontmatter.modified;
+        return lastTouched && lastTouched < cutoffStr;
+    })
+        .sort((a, b) => {
+        const aDate = a.frontmatter.last_reviewed ||
+            a.frontmatter.modified;
+        const bDate = b.frontmatter.last_reviewed ||
+            b.frontmatter.modified;
+        return (aDate || "").localeCompare(bDate || "");
+    })
+        .slice(0, parseInt(opts.limit));
+    if (stale.length === 0) {
+        console.log(`No memories older than ${threshold} days.`);
+        return;
+    }
+    console.log(`${stale.length} memories not touched in ${threshold}+ days:\n`);
+    for (const m of stale) {
+        const lr = m.frontmatter.last_reviewed;
+        console.log(`  ${m.frontmatter.title}`);
+        console.log(`  ${m.sourceLabel}:${m.relativePath}`);
+        console.log(`  Modified: ${m.frontmatter.modified}${lr ? `, Reviewed: ${lr}` : ""}`);
+        console.log();
+    }
+}

package/dist/lib/statsCommand.d.ts

@@ -0,0 +1,6 @@
+export type StatsCommandOptions = {
+    json?: boolean;
+    byProject?: boolean;
+    all?: boolean;
+};
+export declare function runStatsCommand(opts: StatsCommandOptions): Promise<void>;