gnosys 5.11.4 → 5.12.2

package/dist/lib/syncStaging.d.ts

@@ -0,0 +1,79 @@
+/**
+ * v13 hardened JSON staging for multi-machine sync.
+ *
+ * Clients write small JSON files under master-folder/.gnosys-staging/<machineId>/.
+ * Master ingest walks files ordered by ledger firstSeenAt (see GnosysDB.sync_staging_ledger).
+ */
+import type { GnosysDB } from "./db.js";
+/** Current staged-memory JSON schema version. */
+export declare const STAGING_SCHEMA_VERSION = 1;
+export declare const KNOWN_STAGING_SCHEMA_VERSIONS: Set<number>;
+export declare const UNKNOWN_SCHEMA_MESSAGE = "Update your master machine to a newer version of Gnosys.";
+export interface StagedMemoryPayload {
+    schemaVersion: number;
+    id: string;
+    title: string;
+    category: string;
+    content: string;
+    tags: string[];
+    project_id: string | null;
+    scope: string;
+    machineId: string;
+    writtenAt: string;
+    checksum: string;
+}
+export type StagedFileParseResult = {
+    ok: true;
+    payload: StagedMemoryPayload;
+    filePath: string;
+} | {
+    ok: false;
+    filePath: string;
+    reason: string;
+    quarantine: boolean;
+};
+export declare function stagingRoot(masterPath: string): string;
+export declare function machineStagingDir(masterPath: string, machineId: string): string;
+export declare function clientPresencePath(masterPath: string, machineId: string): string;
+export declare function failedQuarantineDir(masterPath: string, machineId: string): string;
+export declare function buildStagingFileName(memoryUlid: string, unixMs?: number): string;
+/** SHA-256 of canonical JSON body (all fields except checksum). */
+export declare function stagingPayloadChecksum(body: Omit<StagedMemoryPayload, "checksum">): string;
+export declare function buildStagedMemoryPayload(input: {
+    id: string;
+    title: string;
+    category: string;
+    content: string;
+    machineId: string;
+    tags?: string[];
+    project_id?: string | null;
+    scope?: string;
+    writtenAt?: string;
+    schemaVersion?: number;
+}): StagedMemoryPayload;
+/**
+ * Atomically write a staged memory JSON file (`.tmp` in the same directory, then rename).
+ * Returns the final file path relative to the machine staging dir.
+ */
+export declare function writeStagedMemoryFile(masterPath: string, machineId: string, payload: StagedMemoryPayload): string;
+export declare function parseStagedFile(filePath: string): StagedFileParseResult;
+/** Move a bad staging file into machineId/failed/ (does not delete). */
+export declare function quarantineStagingFile(filePath: string, masterPath: string, machineId: string): string;
+/** Move stale `.tmp` files in a machine staging dir into `failed/`. */
+export declare function quarantineStaleTmpFiles(masterPath: string, machineId: string): number;
+export declare function countFailedStagingFiles(masterPath: string, machineId: string): number;
+export interface StagingQueueEntry {
+    filePath: string;
+    fileName: string;
+    memoryUlid: string;
+    sortKey: string;
+}
+/**
+ * List pending `.json` staging files for a machine (excludes failed/, tmp, presence).
+ * Sort by ledger firstSeenAt when db is provided, else by filename timestamp prefix.
+ */
+export declare function listPendingStagingQueue(masterPath: string, machineId: string, masterDb?: GnosysDB): StagingQueueEntry[];
+/** Master read-back: memory row exists after ingest before deleting staging file. */
+export declare function verifyMemoryExistsInDb(db: GnosysDB, memoryUlid: string): boolean;
+/** Record first observation in the master ledger (idempotent upsert without clobbering status). */
+export declare function observeStagingFile(masterDb: GnosysDB, machineId: string, fileName: string, memoryUlid: string | null): void;

package/dist/lib/syncStaging.js

@@ -0,0 +1,237 @@
+/**
+ * v13 hardened JSON staging for multi-machine sync.
+ *
+ * Clients write small JSON files under master-folder/.gnosys-staging/<machineId>/.
+ * Master ingest walks files ordered by ledger firstSeenAt (see GnosysDB.sync_staging_ledger).
+ */
+import { createHash, randomBytes } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, } from "fs";
+import path from "path";
+import { atomicWriteFileSync } from "./atomicWrite.js";
+/** Current staged-memory JSON schema version. */
+export const STAGING_SCHEMA_VERSION = 1;
+export const KNOWN_STAGING_SCHEMA_VERSIONS = new Set([STAGING_SCHEMA_VERSION]);
+export const UNKNOWN_SCHEMA_MESSAGE = "Update your master machine to a newer version of Gnosys.";
+const STAGING_DIR = ".gnosys-staging";
+const FAILED_DIR = "failed";
+const PRESENCE_FILE = ".presence.json";
+export function stagingRoot(masterPath) {
+    return path.join(masterPath, STAGING_DIR);
+}
+export function machineStagingDir(masterPath, machineId) {
+    return path.join(stagingRoot(masterPath), machineId);
+}
+export function clientPresencePath(masterPath, machineId) {
+    return path.join(machineStagingDir(masterPath, machineId), PRESENCE_FILE);
+}
+export function failedQuarantineDir(masterPath, machineId) {
+    return path.join(machineStagingDir(masterPath, machineId), FAILED_DIR);
+}
+export function buildStagingFileName(memoryUlid, unixMs = Date.now()) {
+    return `${unixMs}-${memoryUlid}.json`;
+}
+/** SHA-256 of canonical JSON body (all fields except checksum). */
+export function stagingPayloadChecksum(body) {
+    const canonical = JSON.stringify({
+        schemaVersion: body.schemaVersion,
+        id: body.id,
+        title: body.title,
+        category: body.category,
+        content: body.content,
+        tags: body.tags,
+        project_id: body.project_id,
+        scope: body.scope,
+        machineId: body.machineId,
+        writtenAt: body.writtenAt,
+    });
+    return createHash("sha256").update(canonical, "utf-8").digest("hex");
+}
+export function buildStagedMemoryPayload(input) {
+    const bodyWithoutChecksum = {
+        schemaVersion: input.schemaVersion ?? STAGING_SCHEMA_VERSION,
+        id: input.id,
+        title: input.title,
+        category: input.category,
+        content: input.content,
+        tags: input.tags ?? [],
+        project_id: input.project_id ?? null,
+        scope: input.scope ?? "project",
+        machineId: input.machineId,
+        writtenAt: input.writtenAt ?? new Date().toISOString(),
+    };
+    return {
+        ...bodyWithoutChecksum,
+        checksum: stagingPayloadChecksum(bodyWithoutChecksum),
+    };
+}
+/**
+ * Atomically write a staged memory JSON file (`.tmp` in the same directory, then rename).
+ * Returns the final file path relative to the machine staging dir.
+ */
+export function writeStagedMemoryFile(masterPath, machineId, payload) {
+    const dir = machineStagingDir(masterPath, machineId);
+    mkdirSync(dir, { recursive: true });
+    const fileName = buildStagingFileName(payload.id);
+    const dest = path.join(dir, fileName);
+    const tmp = path.join(dir, `.${fileName}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
+    const data = JSON.stringify(payload, null, 2) + "\n";
+    try {
+        atomicWriteFileSync(tmp, data);
+        // read-back verify before rename (catches torn/partial writes on share)
+        const roundTrip = readFileSync(tmp, "utf-8");
+        const parsed = parseStagedFileContent(roundTrip, dest);
+        if (!parsed.ok) {
+            throw new Error(parsed.reason);
+        }
+        renameSync(tmp, dest);
+        return fileName;
+    }
+    catch (err) {
+        try {
+            if (existsSync(tmp))
+                unlinkSync(tmp);
+        }
+        catch {
+            // ignore
+        }
+        throw err;
+    }
+}
+function parseStagedFileContent(raw, filePath) {
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, filePath, reason: "invalid JSON", quarantine: true };
+    }
+    if (!json || typeof json !== "object") {
+        return { ok: false, filePath, reason: "payload is not an object", quarantine: true };
+    }
+    const o = json;
+    const schemaVersion = typeof o.schemaVersion === "number" ? o.schemaVersion : -1;
+    if (!KNOWN_STAGING_SCHEMA_VERSIONS.has(schemaVersion)) {
+        return {
+            ok: false,
+            filePath,
+            reason: UNKNOWN_SCHEMA_MESSAGE,
+            quarantine: true,
+        };
+    }
+    const id = typeof o.id === "string" ? o.id : "";
+    const checksum = typeof o.checksum === "string" ? o.checksum : "";
+    const payload = {
+        schemaVersion,
+        id,
+        title: String(o.title ?? ""),
+        category: String(o.category ?? ""),
+        content: String(o.content ?? ""),
+        tags: Array.isArray(o.tags) ? o.tags.filter((t) => typeof t === "string") : [],
+        project_id: typeof o.project_id === "string" ? o.project_id : null,
+        scope: typeof o.scope === "string" ? o.scope : "project",
+        machineId: String(o.machineId ?? ""),
+        writtenAt: String(o.writtenAt ?? ""),
+        checksum,
+    };
+    const expected = stagingPayloadChecksum(payload);
+    if (!checksum || expected !== checksum) {
+        return { ok: false, filePath, reason: "checksum mismatch", quarantine: true };
+    }
+    if (!id) {
+        return { ok: false, filePath, reason: "missing memory id (ULID)", quarantine: true };
+    }
+    return { ok: true, payload, filePath };
+}
+export function parseStagedFile(filePath) {
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        return parseStagedFileContent(raw, filePath);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            filePath,
+            reason: err instanceof Error ? err.message : String(err),
+            quarantine: true,
+        };
+    }
+}
+/** Move a bad staging file into machineId/failed/ (does not delete). */
+export function quarantineStagingFile(filePath, masterPath, machineId) {
+    const failedDir = failedQuarantineDir(masterPath, machineId);
+    mkdirSync(failedDir, { recursive: true });
+    const base = path.basename(filePath);
+    const dest = path.join(failedDir, base);
+    if (existsSync(dest)) {
+        const stamped = `${Date.now()}-${base}`;
+        renameSync(filePath, path.join(failedDir, stamped));
+        return path.join(failedDir, stamped);
+    }
+    renameSync(filePath, dest);
+    return dest;
+}
+/** Move stale `.tmp` files in a machine staging dir into `failed/`. */
+export function quarantineStaleTmpFiles(masterPath, machineId) {
+    const dir = machineStagingDir(masterPath, machineId);
+    if (!existsSync(dir))
+        return 0;
+    let moved = 0;
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".tmp"))
+            continue;
+        quarantineStagingFile(path.join(dir, name), masterPath, machineId);
+        moved++;
+    }
+    return moved;
+}
+export function countFailedStagingFiles(masterPath, machineId) {
+    const failedDir = failedQuarantineDir(masterPath, machineId);
+    if (!existsSync(failedDir))
+        return 0;
+    try {
+        return readdirSync(failedDir).filter((n) => n.endsWith(".json") || n.endsWith(".tmp")).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * List pending `.json` staging files for a machine (excludes failed/, tmp, presence).
+ * Sort by ledger firstSeenAt when db is provided, else by filename timestamp prefix.
+ */
+export function listPendingStagingQueue(masterPath, machineId, masterDb) {
+    const dir = machineStagingDir(masterPath, machineId);
+    if (!existsSync(dir))
+        return [];
+    const entries = [];
+    for (const name of readdirSync(dir)) {
+        if (name === FAILED_DIR || name === PRESENCE_FILE || name.endsWith(".tmp"))
+            continue;
+        if (!name.endsWith(".json"))
+            continue;
+        const filePath = path.join(dir, name);
+        const ulid = name.replace(/^\d+-/, "").replace(/\.json$/, "");
+        const stagingKey = `${machineId}/${name}`;
+        const firstSeen = masterDb?.isAvailable() ? masterDb.getStagingLedgerFirstSeenAt(stagingKey) : null;
+        const sortKey = firstSeen ? `${firstSeen}\0${name}` : name;
+        entries.push({ filePath, fileName: name, memoryUlid: ulid, sortKey });
+    }
+    entries.sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+    return entries;
+}
+/** Master read-back: memory row exists after ingest before deleting staging file. */
+export function verifyMemoryExistsInDb(db, memoryUlid) {
+    if (!db.isAvailable())
+        return false;
+    return db.getMemory(memoryUlid) !== null;
+}
+/** Record first observation in the master ledger (idempotent upsert without clobbering status). */
+export function observeStagingFile(masterDb, machineId, fileName, memoryUlid) {
+    const stagingKey = `${machineId}/${fileName}`;
+    masterDb.recordStagingLedgerEntry({
+        stagingKey,
+        machineId,
+        memoryUlid,
+        firstSeenAt: new Date().toISOString(),
+    });
+}

package/dist/lib/tagsAddCommand.d.ts

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

package/dist/lib/tagsAddCommand.js

@@ -0,0 +1,18 @@
+import { GnosysTagRegistry } from "./tags.js";
+export async function runTagsAddCommand(getResolver, opts) {
+    const resolver = await getResolver();
+    const writeTarget = resolver.getWriteTarget();
+    if (!writeTarget) {
+        console.error("No store found.");
+        process.exit(1);
+    }
+    const tagRegistry = new GnosysTagRegistry(writeTarget.store.getStorePath());
+    await tagRegistry.load();
+    const added = await tagRegistry.addTag(opts.category, opts.tag);
+    if (added) {
+        console.log(`Tag '${opts.tag}' added to category '${opts.category}'.`);
+    }
+    else {
+        console.log(`Tag '${opts.tag}' already exists in '${opts.category}'.`);
+    }
+}

package/dist/lib/tagsCommand.d.ts

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

package/dist/lib/tagsCommand.js

@@ -0,0 +1,16 @@
+import { GnosysTagRegistry } from "./tags.js";
+export async function runTagsCommand(getResolver) {
+    const resolver = await getResolver();
+    const writeTarget = resolver.getWriteTarget();
+    if (!writeTarget) {
+        console.error("No store found.");
+        process.exit(1);
+    }
+    const tagRegistry = new GnosysTagRegistry(writeTarget.store.getStorePath());
+    await tagRegistry.load();
+    const registry = tagRegistry.getRegistry();
+    for (const [category, tags] of Object.entries(registry)) {
+        console.log(`\n${category}:`);
+        console.log(`  ${tags.sort().join(", ")}`);
+    }
+}

package/dist/lib/timelineCommand.d.ts

@@ -0,0 +1,7 @@
+export type TimelineCommandOptions = {
+    period: string;
+    project?: string;
+    limitTitles: string;
+    json?: boolean;
+};
+export declare function runTimelineCommand(opts: TimelineCommandOptions): Promise<void>;

package/dist/lib/timelineCommand.js

@@ -0,0 +1,49 @@
+import { GnosysDB } from "./db.js";
+import { groupDbByPeriod } from "./timeline.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runTimelineCommand(opts) {
+    const centralDb = GnosysDB.openCentral();
+    if (!centralDb.isAvailable()) {
+        console.error("Central DB unavailable.");
+        process.exit(1);
+    }
+    try {
+        const memories = opts.project
+            ? centralDb.getMemoriesByProject(opts.project)
+            : centralDb.getActiveMemories();
+        if (memories.length === 0) {
+            outputResult(!!opts.json, { period: opts.period, count: 0, entries: [] }, () => {
+                console.log("No memories found.");
+            });
+            return;
+        }
+        const entries = groupDbByPeriod(memories, opts.period);
+        const titleLimit = Math.max(0, parseInt(opts.limitTitles, 10) || 5);
+        outputResult(!!opts.json, { period: opts.period, count: memories.length, entries }, () => {
+            console.log(`Knowledge Timeline (by ${opts.period}, ${memories.length} memories):\n`);
+            for (const entry of entries) {
+                const parts = [];
+                if (entry.created > 0)
+                    parts.push(`${entry.created} created`);
+                if (entry.modified > 0)
+                    parts.push(`${entry.modified} modified`);
+                console.log(`  ${entry.period}: ${parts.join(", ")}`);
+                if (entry.titles.length > 0 && entry.titles.length <= titleLimit) {
+                    for (const t of entry.titles) {
+                        console.log(`    + ${t}`);
+                    }
+                }
+            }
+        });
+    }
+    finally {
+        centralDb.close();
+    }
+}

package/dist/lib/traceCommand.d.ts

@@ -0,0 +1,6 @@
+export type TraceCommandOptions = {
+    maxFiles?: string;
+    projectId?: string;
+    json?: boolean;
+};
+export declare function runTraceCommand(directory: string, opts: TraceCommandOptions): Promise<void>;

package/dist/lib/traceCommand.js

@@ -0,0 +1,39 @@
+export async function runTraceCommand(directory, opts) {
+    let db;
+    try {
+        const { traceCodebase } = await import("./trace.js");
+        const { GnosysDB: GnosysDBClass } = await import("./db.js");
+        const dbDir = GnosysDBClass.getCentralDbDir();
+        db = new GnosysDBClass(dbDir);
+        if (!db.isAvailable()) {
+            console.error("Error: GnosysDB not available. Install it with: npm install better-sqlite3");
+            process.exit(1);
+        }
+        const result = traceCodebase(db, directory, {
+            projectId: opts.projectId,
+            maxFiles: opts.maxFiles ? parseInt(opts.maxFiles, 10) : undefined,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Trace complete:`);
+            console.log(`  Files scanned:        ${result.filesScanned}`);
+            console.log(`  Functions found:       ${result.functionsFound}`);
+            console.log(`  Memories created:      ${result.memoriesCreated}`);
+            console.log(`  Relationships created: ${result.relationshipsCreated}`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Trace failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+    finally {
+        db?.close();
+    }
+}

package/dist/lib/traverseCommand.d.ts

@@ -0,0 +1,6 @@
+export type TraverseCommandOptions = {
+    depth?: string;
+    relTypes?: string;
+    json?: boolean;
+};
+export declare function runTraverseCommand(memoryId: string, opts: TraverseCommandOptions): Promise<void>;

package/dist/lib/traverseCommand.js

@@ -0,0 +1,58 @@
+export async function runTraverseCommand(memoryId, opts) {
+    let db;
+    try {
+        const { GnosysDB: GnosysDBClass } = await import("./db.js");
+        const { handleRequest } = await import("../sandbox/server.js");
+        const dbDir = GnosysDBClass.getCentralDbDir();
+        db = new GnosysDBClass(dbDir);
+        if (!db.isAvailable()) {
+            console.error("Error: GnosysDB not available. Install it with: npm install better-sqlite3");
+            process.exit(1);
+        }
+        const params = {
+            id: memoryId,
+            depth: opts.depth ? parseInt(opts.depth, 10) : 3,
+        };
+        if (opts.relTypes)
+            params.rel_types = opts.relTypes.split(",").map((s) => s.trim());
+        const res = handleRequest(db, {
+            id: "cli-traverse",
+            method: "traverse",
+            params,
+        });
+        if (!res.ok) {
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: false, error: res.error }));
+            }
+            else {
+                console.error(`Traverse failed: ${res.error}`);
+            }
+            process.exit(1);
+        }
+        const result = res.result;
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Traversal from ${memoryId} (depth: ${result.depth}):`);
+            console.log(`  Total nodes: ${result.total}\n`);
+            for (const node of result.nodes) {
+                const indent = "  ".repeat(node.depth + 1);
+                const via = node.via_rel ? ` ← [${node.via_rel}] from ${node.via_from}` : " (root)";
+                console.log(`${indent}${node.id}: ${node.title} (conf: ${node.confidence.toFixed(2)})${via}`);
+            }
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Traverse failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+    finally {
+        db?.close();
+    }
+}

package/dist/lib/updateCommand.d.ts

@@ -0,0 +1,13 @@
+import type { GnosysResolver } from "./resolver.js";
+export type UpdateCommandOptions = {
+    title?: string;
+    status?: string;
+    confidence?: string;
+    relevance?: string;
+    supersedes?: string;
+    supersededBy?: string;
+    content?: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runUpdateCommand(getResolver: GetResolver, memoryPath: string, opts: UpdateCommandOptions): Promise<void>;
+export {};

package/dist/lib/updateCommand.js

@@ -0,0 +1,67 @@
+import { GnosysDB } from "./db.js";
+export async function runUpdateCommand(getResolver, memoryPath, opts) {
+    let memoryId;
+    let currentTitle;
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+    }
+    catch {
+        /* handled below */
+    }
+    if (centralDb?.isAvailable()) {
+        const dbMem = centralDb.getMemory(memoryPath);
+        if (dbMem) {
+            memoryId = dbMem.id;
+            currentTitle = dbMem.title;
+        }
+        else {
+            const resolver = await getResolver();
+            const memory = await resolver.readMemory(memoryPath);
+            if (!memory?.frontmatter.id) {
+                console.error(`Memory not found: ${memoryPath}`);
+                centralDb?.close();
+                process.exit(1);
+            }
+            memoryId = memory.frontmatter.id;
+            currentTitle = memory.frontmatter.title || memoryPath;
+        }
+    }
+    else {
+        console.error("Central DB not available.");
+        process.exit(1);
+    }
+    const updates = {};
+    if (opts.title !== undefined)
+        updates.title = opts.title;
+    if (opts.status !== undefined)
+        updates.status = opts.status;
+    if (opts.confidence !== undefined)
+        updates.confidence = parseFloat(opts.confidence);
+    if (opts.relevance !== undefined)
+        updates.relevance = opts.relevance;
+    if (opts.supersedes !== undefined)
+        updates.supersedes = opts.supersedes;
+    if (opts.supersededBy !== undefined)
+        updates.superseded_by = opts.supersededBy;
+    const fullContent = opts.content
+        ? `# ${opts.title || currentTitle}\n\n${opts.content}`
+        : undefined;
+    try {
+        const { syncUpdateToDb } = await import("./dbWrite.js");
+        syncUpdateToDb(centralDb, memoryId, updates, fullContent);
+        if (opts.supersedes) {
+            syncUpdateToDb(centralDb, opts.supersedes, { superseded_by: memoryId, status: "superseded" });
+            console.log(`Cross-linked: ${opts.supersedes} marked as superseded.`);
+        }
+    }
+    finally {
+        centralDb?.close();
+    }
+    const changedFields = Object.keys(updates);
+    if (opts.content)
+        changedFields.push("content");
+    console.log(`Memory updated: ${opts.title || currentTitle}`);
+    console.log(`ID: ${memoryId}`);
+    console.log(`Changed: ${changedFields.join(", ")}`);
+}

package/dist/lib/updateStatusCommand.d.ts

@@ -0,0 +1,5 @@
+export type UpdateStatusCommandOptions = {
+    directory?: string;
+    project?: string;
+};
+export declare function runUpdateStatusCommand(opts: UpdateStatusCommandOptions): Promise<void>;

package/dist/lib/updateStatusCommand.js

@@ -0,0 +1,38 @@
+import { GnosysDB } from "./db.js";
+export async function runUpdateStatusCommand(opts) {
+    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 { generateStatusPrompt } = await import("./portfolio.js");
+        let pid = opts.project || null;
+        if (!pid)
+            pid = await detectCurrentProject(centralDb, opts.directory || undefined);
+        if (!pid) {
+            console.error("No project specified and none detected.");
+            process.exitCode = 1;
+            return;
+        }
+        const project = centralDb.getProject(pid);
+        if (!project) {
+            console.error(`Project not found: ${pid}`);
+            process.exitCode = 1;
+            return;
+        }
+        const prompt = generateStatusPrompt(project.name, project.working_directory);
+        console.log(prompt);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/webAddCommand.d.ts

@@ -0,0 +1,8 @@
+import type { GetWebStorePath } from "./webInitCommand.js";
+export type WebAddCommandOptions = {
+    category?: string;
+    llm: boolean;
+    reindex: boolean;
+    json?: boolean;
+};
+export declare function runWebAddCommand(getWebStorePath: GetWebStorePath, url: string, opts: WebAddCommandOptions): Promise<void>;