gnosys 5.11.4 → 5.12.2

package/dist/lib/statsCommand.js

@@ -0,0 +1,142 @@
+import { GnosysDB } from "./db.js";
+import { findProjectIdentity } from "./projectIdentity.js";
+import { computeStats } from "./timeline.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runStatsCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available. Run 'gnosys init' first.");
+            process.exit(1);
+        }
+        // v5.7.0: --by-project shows a per-project breakdown across the entire
+        // central DB (memories, archived, never reinforced, etc.) as a table.
+        if (opts.byProject) {
+            const projects = centralDb.getAllProjects();
+            const all = centralDb.getAllMemories();
+            const rows = projects.map((p) => {
+                const ms = all.filter((m) => m.project_id === p.id);
+                const active = ms.filter((m) => m.tier === "active" && m.status === "active").length;
+                const archived = ms.filter((m) => m.tier === "archive").length;
+                const reinforced = ms.reduce((sum, m) => sum + (m.reinforcement_count ?? 0), 0);
+                const lastTouch = ms.reduce((m, x) => (x.modified > m ? x.modified : m), "0");
+                return { name: p.name, id: p.id, active, archived, reinforced, lastTouch };
+            });
+            // User/global memories (no project_id)
+            const userScope = all.filter((m) => !m.project_id && m.scope === "user");
+            const globalScope = all.filter((m) => !m.project_id && m.scope === "global");
+            if (userScope.length > 0) {
+                rows.push({
+                    name: "(user)",
+                    id: "—",
+                    active: userScope.filter((m) => m.tier === "active" && m.status === "active").length,
+                    archived: userScope.filter((m) => m.tier === "archive").length,
+                    reinforced: userScope.reduce((sum, m) => sum + (m.reinforcement_count ?? 0), 0),
+                    lastTouch: userScope.reduce((m, x) => (x.modified > m ? x.modified : m), "0"),
+                });
+            }
+            if (globalScope.length > 0) {
+                rows.push({
+                    name: "(global)",
+                    id: "—",
+                    active: globalScope.filter((m) => m.tier === "active" && m.status === "active").length,
+                    archived: globalScope.filter((m) => m.tier === "archive").length,
+                    reinforced: globalScope.reduce((sum, m) => sum + (m.reinforcement_count ?? 0), 0),
+                    lastTouch: globalScope.reduce((m, x) => (x.modified > m ? x.modified : m), "0"),
+                });
+            }
+            rows.sort((a, b) => b.active - a.active);
+            if (opts.json) {
+                console.log(JSON.stringify({ rows }, null, 2));
+                return;
+            }
+            const nameW = Math.max(8, ...rows.map((r) => r.name.length));
+            const idW = 12;
+            console.log("");
+            console.log(`  ${"PROJECT".padEnd(nameW)}  ${"ID".padEnd(idW)}  ${"ACTIVE".padStart(7)}  ${"ARCHIVED".padStart(8)}  ${"REINF".padStart(6)}  LAST MODIFIED`);
+            console.log(`  ${"-".repeat(nameW + idW + 7 + 8 + 6 + 19 + 10)}`);
+            for (const r of rows) {
+                const last = r.lastTouch === "0" ? "—" : r.lastTouch.slice(0, 19);
+                const idShort = r.id === "—" ? "—" : r.id.slice(0, idW);
+                console.log(`  ${r.name.padEnd(nameW)}  ${idShort.padEnd(idW)}  ${String(r.active).padStart(7)}  ${String(r.archived).padStart(8)}  ${String(r.reinforced).padStart(6)}  ${last}`);
+            }
+            const totalActive = rows.reduce((s, r) => s + r.active, 0);
+            console.log(`  ${"-".repeat(nameW + idW + 7 + 8 + 6 + 19 + 10)}`);
+            console.log(`  ${"TOTAL".padEnd(nameW)}  ${" ".repeat(idW)}  ${String(totalActive).padStart(7)}`);
+            console.log("");
+            return;
+        }
+        // Default behavior: scoped stats (current project + user/global, OR --all)
+        const projIdentity = await findProjectIdentity(process.cwd());
+        const projectId = !opts.all && projIdentity?.identity.projectId || null;
+        let dbMemories = centralDb.getActiveMemories();
+        if (projectId) {
+            dbMemories = dbMemories.filter((m) => m.project_id === projectId || m.scope === "user" || m.scope === "global");
+        }
+        if (dbMemories.length === 0) {
+            outputResult(!!opts.json, { totalCount: 0 }, () => {
+                console.log("No memories found.");
+            });
+            return;
+        }
+        // Convert DbMemory[] to Memory[] shape for computeStats
+        const allMemories = dbMemories.map((m) => ({
+            frontmatter: {
+                id: m.id,
+                title: m.title,
+                category: m.category,
+                tags: (() => { try {
+                    return JSON.parse(m.tags || "[]");
+                }
+                catch {
+                    return [];
+                } })(),
+                relevance: m.relevance,
+                author: m.author,
+                authority: m.authority,
+                confidence: m.confidence,
+                created: m.created,
+                modified: m.modified,
+                status: m.status,
+            },
+            content: m.content,
+            filePath: "",
+            relativePath: "",
+        }));
+        const stats = computeStats(allMemories);
+        outputResult(!!opts.json, stats, () => {
+            console.log(`Gnosys Store Statistics:\n`);
+            console.log(`  Total memories: ${stats.totalCount}`);
+            console.log(`  Average confidence: ${stats.averageConfidence}`);
+            console.log(`  Date range: ${stats.oldestCreated} → ${stats.newestCreated}`);
+            console.log(`  Last modified: ${stats.lastModified}`);
+            console.log(`\n  By category:`);
+            for (const [cat, count] of Object.entries(stats.byCategory).sort((a, b) => b[1] - a[1])) {
+                console.log(`    ${cat}: ${count}`);
+            }
+            console.log(`\n  By status:`);
+            for (const [st, count] of Object.entries(stats.byStatus)) {
+                console.log(`    ${st}: ${count}`);
+            }
+            console.log(`\n  By author:`);
+            for (const [author, count] of Object.entries(stats.byAuthor)) {
+                console.log(`    ${author}: ${count}`);
+            }
+        });
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/statusCommand.d.ts

@@ -0,0 +1,18 @@
+import type { GnosysConfig } from "./config.js";
+import type { GnosysResolver } from "./resolver.js";
+export type StatusCommandOptions = {
+    directory?: string;
+    project?: string;
+    global?: boolean;
+    projects?: boolean;
+    remote?: boolean;
+    web?: boolean;
+    system?: boolean;
+    json: boolean;
+};
+export type StatusCommandDeps = {
+    getResolver: () => Promise<GnosysResolver>;
+    loadConfig: (path: string) => Promise<GnosysConfig>;
+    pkgVersion: string;
+};
+export declare function runStatusCommand(opts: StatusCommandOptions, deps: StatusCommandDeps): Promise<void>;

package/dist/lib/statusCommand.js

@@ -0,0 +1,250 @@
+import path from "path";
+import { GnosysDB } from "./db.js";
+export async function runStatusCommand(opts, deps) {
+    // v5.7.1: --projects supersedes --global (kept as alias).
+    if (opts.projects)
+        opts.global = true;
+    // v5.7.1: --remote — dispatch to RemoteSync.getStatus()
+    if (opts.remote) {
+        let remoteCentralDb = null;
+        try {
+            remoteCentralDb = GnosysDB.openLocal();
+            if (!remoteCentralDb.isAvailable()) {
+                console.error("Central DB not available.");
+                process.exitCode = 1;
+                return;
+            }
+            const remotePath = remoteCentralDb.getMeta("remote_path");
+            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. Run 'gnosys setup remote' to set up multi-machine sync.");
+                }
+                return;
+            }
+            const { RemoteSync, formatStatus } = await import("./remote.js");
+            const { withHeartbeat } = await import("./heartbeat.js");
+            let sync = null;
+            try {
+                sync = new RemoteSync(remoteCentralDb, 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();
+            }
+            return;
+        }
+        catch (err) {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+            process.exitCode = 1;
+            return;
+        }
+        finally {
+            remoteCentralDb?.close();
+        }
+    }
+    // --system delegates to the dashboard formatter (formerly `gnosys dashboard`).
+    if (opts.system) {
+        let dashDb = null;
+        try {
+            const { collectDashboardData, formatDashboard, formatDashboardJSON } = await import("./dashboard.js");
+            const resolver = await deps.getResolver();
+            const stores = resolver.getStores();
+            if (stores.length === 0) {
+                console.error("No Gnosys stores found. Run gnosys init first.");
+                process.exitCode = 1;
+                return;
+            }
+            const cfg = await deps.loadConfig(stores[0].path);
+            try {
+                dashDb = GnosysDB.openCentral();
+                if (!dashDb.isAvailable() || !dashDb.isMigrated()) {
+                    dashDb.close();
+                    dashDb = null;
+                }
+            }
+            catch {
+                dashDb?.close();
+                dashDb = null;
+            }
+            const data = await collectDashboardData(resolver, cfg, deps.pkgVersion, dashDb ?? undefined);
+            console.log(opts.json ? formatDashboardJSON(data) : formatDashboard(data));
+        }
+        catch (err) {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+            process.exitCode = 1;
+            return;
+        }
+        finally {
+            dashDb?.close();
+        }
+        return;
+    }
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const { detectCurrentProject } = await import("./federated.js");
+        const { generatePortfolio } = await import("./portfolio.js");
+        const report = generatePortfolio(centralDb);
+        // --web: regenerate HTML dashboard and open it
+        if (opts.web) {
+            const { generatePortfolioHtml } = await import("./portfolioHtml.js");
+            const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+            const dashboardPath = path.join(home, "gnosys-dashboard.html");
+            const { writeFileSync } = await import("fs");
+            writeFileSync(dashboardPath, generatePortfolioHtml(report, dashboardPath), "utf-8");
+            const { execFile } = await import("child_process");
+            execFile("open", [dashboardPath]);
+            console.log(`Dashboard opened: ${dashboardPath}`);
+            return;
+        }
+        // --global: show all projects
+        if (opts.global) {
+            if (opts.json) {
+                console.log(JSON.stringify(report, null, 2));
+                return;
+            }
+            console.log(`\n  Portfolio — ${report.totalProjects} projects, ${report.totalMemories} memories\n`);
+            // Action items summary
+            if (report.allActionItems.length > 0) {
+                console.log(`  \x1b[31mACTION ITEMS (${report.allActionItems.length}):\x1b[0m`);
+                for (const a of report.allActionItems.slice(0, 8)) {
+                    const icon = a.type === "question" ? "?" : a.type === "blocker" ? "!" : a.type === "manual" ? ">" : "*";
+                    console.log(`    [${icon}] ${a.projectName}: ${a.text.slice(0, 80)}`);
+                }
+                if (report.allActionItems.length > 8) {
+                    console.log(`    ... and ${report.allActionItems.length - 8} more`);
+                }
+                console.log("");
+            }
+            // Per-project summary
+            for (const snap of report.projects) {
+                const r = snap.readiness;
+                const color = r.score >= 90 ? "\x1b[32m" : r.score >= 65 ? "\x1b[34m" : r.score >= 40 ? "\x1b[33m" : "\x1b[31m";
+                const reset = "\x1b[0m";
+                const blockers = snap.actionItems.length + r.blocking.length;
+                const blockerStr = blockers > 0 ? ` — \x1b[31m${blockers} blocker${blockers !== 1 ? "s" : ""}\x1b[0m` : "";
+                console.log(`  ${color}${String(r.score).padStart(3)}%${reset} ${r.label.padEnd(12)} ${snap.project.name}${blockerStr}`);
+            }
+            console.log(`\n  Run 'gnosys status --web' to open the visual dashboard.`);
+            return;
+        }
+        // Single project (default): auto-detect from cwd
+        let pid = opts.project || null;
+        if (!pid)
+            pid = await detectCurrentProject(centralDb, opts.directory || undefined);
+        if (!pid) {
+            console.error("No project detected. Run from a project directory, use --project, or use --global for all.");
+            process.exitCode = 1;
+            return;
+        }
+        const project = centralDb.getProject(pid);
+        if (!project) {
+            console.error(`Project not found: ${pid}`);
+            process.exitCode = 1;
+            return;
+        }
+        const snap = report.projects.find((s) => s.project.id === pid);
+        if (!snap) {
+            console.error(`No memories found for project: ${project.name}`);
+            console.log(`\nRun 'gnosys update-status' to create a status snapshot.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({
+                project: project.name,
+                readiness: snap.readiness,
+                actionItems: snap.actionItems,
+                memoryCounts: snap.memoryCounts,
+                latestStatus: snap.latestStatus
+                    ? {
+                        id: snap.latestStatus.id,
+                        title: snap.latestStatus.title,
+                        modified: snap.latestStatus.modified,
+                    }
+                    : null,
+            }, null, 2));
+            return;
+        }
+        // Formatted output
+        const r = snap.readiness;
+        const color = r.score >= 90 ? "\x1b[32m" : r.score >= 65 ? "\x1b[34m" : r.score >= 40 ? "\x1b[33m" : "\x1b[31m";
+        const reset = "\x1b[0m";
+        console.log(`\n  ${project.name} — ${color}${r.label} (${r.score}%)${reset}`);
+        console.log(`  ${snap.memoryCounts.total} memories across ${Object.keys(snap.memoryCounts.byCategory).length} categories\n`);
+        if (snap.latestStatus) {
+            const age = Math.floor((Date.now() - new Date(snap.latestStatus.modified).getTime()) / (1000 * 60 * 60 * 24));
+            const stale = age > 7
+                ? ` \x1b[33m(${age}d old — consider running 'gnosys update-status')\x1b[0m`
+                : ` (${age}d ago)`;
+            console.log(`  Last status: ${snap.latestStatus.title}${stale}\n`);
+        }
+        else {
+            console.log(`  \x1b[33mNo status snapshot found. Run 'gnosys update-status' to create one.\x1b[0m\n`);
+        }
+        // Action items
+        if (snap.actionItems.length > 0) {
+            console.log(`  ACTION ITEMS (${snap.actionItems.length}):`);
+            for (const a of snap.actionItems) {
+                const icon = a.type === "question" ? "?" : a.type === "blocker" ? "!" : a.type === "manual" ? ">" : "*";
+                console.log(`    [${icon}] ${a.text}`);
+            }
+            console.log("");
+        }
+        // Blocking
+        if (r.blocking.length > 0) {
+            console.log(`  BLOCKING GO-LIVE (${r.blocking.length}):`);
+            for (const b of r.blocking.slice(0, 10)) {
+                console.log(`    - ${b}`);
+            }
+            if (r.blocking.length > 10)
+                console.log(`    ... and ${r.blocking.length - 10} more`);
+            console.log("");
+        }
+        // Done summary
+        if (r.done.length > 0) {
+            console.log(`  COMPLETED (${r.done.length} items)`);
+            for (const d of r.done.slice(0, 5)) {
+                console.log(`    + ${d}`);
+            }
+            if (r.done.length > 5)
+                console.log(`    ... and ${r.done.length - 5} more`);
+            console.log("");
+        }
+        // Suggest update if no status or stale
+        if (!snap.latestStatus) {
+            console.log(`  Tip: Run 'gnosys update-status' to generate a status snapshot.`);
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/storesCommand.d.ts

@@ -0,0 +1,2 @@
+import type { GnosysResolver } from "./resolver.js";
+export declare function runStoresCommand(getResolver: () => Promise<GnosysResolver>): Promise<void>;

package/dist/lib/storesCommand.js

@@ -0,0 +1,4 @@
+export async function runStoresCommand(getResolver) {
+    const resolver = await getResolver();
+    console.log(resolver.getSummary());
+}

package/dist/lib/syncClient.d.ts

@@ -0,0 +1,41 @@
+/**
+ * v13 client-side sync: reachability heartbeat, offline snapshot rule, pending overlay.
+ */
+import { GnosysDB } from "./db.js";
+import { type MultiMachineRole } from "./machineConfig.js";
+import type { PendingAddRow } from "./clientReadOverlay.js";
+export interface IngestReceipt {
+    ulid: string;
+    outcome: "ingested" | "deduped";
+    at: string;
+}
+export interface ClientReadContext {
+    /** The DB to query for base memories (may be master, snapshot, or local). */
+    db: GnosysDB;
+    /** Original local central DB — never closed by closeClientReadContext. */
+    localDb: GnosysDB;
+    /** Pending-adds to overlay (already filtered by receipts). */
+    pendingOverlay: PendingAddRow[];
+    source: "master" | "snapshot" | "pending-only";
+    masterReachable: boolean;
+    /** When true, closeClientReadContext must close db (not localDb). */
+    ownsReadDb: boolean;
+}
+export interface V13SyncStatus {
+    role: MultiMachineRole | null;
+    masterPath: string | null;
+    masterReachable: boolean;
+    waitingToSync: number;
+    failedToSync: number;
+    pendingOfflineAdds: number;
+    snapshotAge: string | null;
+    lines: string[];
+}
+export declare function isMasterReachable(masterPath: string): boolean;
+export declare function countClientWaitingStaging(masterPath: string, machineId: string): number;
+export declare function listClientReceipts(masterPath: string, machineId: string): IngestReceipt[];
+export declare function getIngestedUlids(masterPath: string, machineId: string): Set<string>;
+export declare function openClientReadContext(localDb: GnosysDB, masterPath: string, machineId: string): ClientReadContext;
+/** Release snapshot/master DB handles opened by openClientReadContext. */
+export declare function closeClientReadContext(ctx: ClientReadContext): void;
+export declare function getV13SyncStatus(localDb: GnosysDB): V13SyncStatus;