gnosys 5.11.3 → 5.12.0

package/dist/lib/webBuildCommand.js

@@ -0,0 +1,65 @@
+import path from "path";
+export async function runWebBuildCommand(getWebStorePath, opts) {
+    try {
+        const { loadConfig } = await import("./config.js");
+        const { ingestSite } = await import("./webIngest.js");
+        const { buildIndex, writeIndex } = await import("./webIndex.js");
+        const gnosysConfig = await loadConfig(await getWebStorePath());
+        const webConfig = gnosysConfig.web;
+        if (!webConfig) {
+            throw new Error("No web configuration found in gnosys.json. Run 'gnosys web init' first.");
+        }
+        // Step 1: Ingest
+        const ingestResult = await ingestSite({
+            source: webConfig.source,
+            sitemapUrl: opts.source || webConfig.sitemapUrl,
+            contentDir: opts.source || webConfig.contentDir,
+            urls: webConfig.urls,
+            outputDir: webConfig.outputDir,
+            exclude: webConfig.exclude,
+            categories: webConfig.categories,
+            llmEnrich: opts.llm ? webConfig.llmEnrich : false,
+            prune: opts.prune || webConfig.prune,
+            concurrency: parseInt(opts.concurrency) || webConfig.concurrency,
+            crawlDelayMs: webConfig.crawlDelayMs,
+            dryRun: opts.dryRun,
+        }, gnosysConfig);
+        // Step 2: Build index (skip if dry run)
+        let indexStats = { documentCount: 0, tokenCount: 0 };
+        if (!opts.dryRun) {
+            const index = await buildIndex(webConfig.outputDir);
+            const indexPath = path.join(webConfig.outputDir, "gnosys-index.json");
+            await writeIndex(index, indexPath);
+            indexStats = {
+                documentCount: index.documentCount,
+                tokenCount: Object.keys(index.invertedIndex).length,
+            };
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ ...ingestResult, index: indexStats }));
+        }
+        else {
+            console.log(`Web build complete (${ingestResult.duration}ms):`);
+            console.log(`  Added:     ${ingestResult.added.length}`);
+            console.log(`  Updated:   ${ingestResult.updated.length}`);
+            console.log(`  Unchanged: ${ingestResult.unchanged.length}`);
+            console.log(`  Removed:   ${ingestResult.removed.length}`);
+            console.log(`  Index:     ${indexStats.documentCount} docs, ${indexStats.tokenCount} tokens`);
+            if (ingestResult.errors.length > 0) {
+                console.log(`  Errors:    ${ingestResult.errors.length}`);
+                for (const e of ingestResult.errors) {
+                    console.log(`    ${e.url}: ${e.error}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Web build failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/webBuildIndexCommand.d.ts

@@ -0,0 +1,8 @@
+import type { GetWebStorePath } from "./webInitCommand.js";
+export type WebBuildIndexCommandOptions = {
+    input?: string;
+    output?: string;
+    stopWords: boolean;
+    json?: boolean;
+};
+export declare function runWebBuildIndexCommand(getWebStorePath: GetWebStorePath, opts: WebBuildIndexCommandOptions): Promise<void>;

package/dist/lib/webBuildIndexCommand.js

@@ -0,0 +1,37 @@
+import path from "path";
+export async function runWebBuildIndexCommand(getWebStorePath, opts) {
+    try {
+        const { loadConfig } = await import("./config.js");
+        const { buildIndex, writeIndex } = await import("./webIndex.js");
+        const gnosysConfig = await loadConfig(await getWebStorePath());
+        const knowledgeDir = opts.input || gnosysConfig.web?.outputDir || "./knowledge";
+        const outputPath = opts.output || path.join(knowledgeDir, "gnosys-index.json");
+        const index = await buildIndex(knowledgeDir, {
+            stopWords: opts.stopWords,
+        });
+        await writeIndex(index, outputPath);
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                documentCount: index.documentCount,
+                tokenCount: Object.keys(index.invertedIndex).length,
+                outputPath,
+            }));
+        }
+        else {
+            console.log(`Search index built:`);
+            console.log(`  Documents: ${index.documentCount}`);
+            console.log(`  Tokens:    ${Object.keys(index.invertedIndex).length}`);
+            console.log(`  Output:    ${outputPath}`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Build index failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/webIngestCommand.d.ts

@@ -0,0 +1,11 @@
+import type { GetWebStorePath } from "./webInitCommand.js";
+export type WebIngestCommandOptions = {
+    source?: string;
+    prune?: boolean;
+    llm: boolean;
+    concurrency: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    json?: boolean;
+};
+export declare function runWebIngestCommand(getWebStorePath: GetWebStorePath, opts: WebIngestCommandOptions): Promise<void>;

package/dist/lib/webIngestCommand.js

@@ -0,0 +1,51 @@
+export async function runWebIngestCommand(getWebStorePath, opts) {
+    try {
+        const { loadConfig } = await import("./config.js");
+        const { ingestSite } = await import("./webIngest.js");
+        const gnosysConfig = await loadConfig(await getWebStorePath());
+        const webConfig = gnosysConfig.web;
+        if (!webConfig) {
+            throw new Error("No web configuration found in gnosys.json. Run 'gnosys web init' first.");
+        }
+        const result = await ingestSite({
+            source: webConfig.source,
+            sitemapUrl: opts.source || webConfig.sitemapUrl,
+            contentDir: opts.source || webConfig.contentDir,
+            urls: webConfig.urls,
+            outputDir: webConfig.outputDir,
+            exclude: webConfig.exclude,
+            categories: webConfig.categories,
+            llmEnrich: opts.llm ? webConfig.llmEnrich : false,
+            prune: opts.prune || webConfig.prune,
+            concurrency: parseInt(opts.concurrency) || webConfig.concurrency,
+            crawlDelayMs: webConfig.crawlDelayMs,
+            dryRun: opts.dryRun,
+            verbose: opts.verbose,
+        }, gnosysConfig);
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Ingestion complete (${result.duration}ms):`);
+            console.log(`  Added:     ${result.added.length}`);
+            console.log(`  Updated:   ${result.updated.length}`);
+            console.log(`  Unchanged: ${result.unchanged.length}`);
+            console.log(`  Removed:   ${result.removed.length}`);
+            if (result.errors.length > 0) {
+                console.log(`  Errors:    ${result.errors.length}`);
+                for (const e of result.errors) {
+                    console.log(`    ${e.url}: ${e.error}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Ingest failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/webInitCommand.d.ts

@@ -0,0 +1,9 @@
+export type WebInitCommandOptions = {
+    source: string;
+    output: string;
+    config: boolean;
+    nonInteractive?: boolean;
+    json?: boolean;
+};
+export type GetWebStorePath = () => Promise<string>;
+export declare function runWebInitCommand(getWebStorePath: GetWebStorePath, opts: WebInitCommandOptions): Promise<void>;

package/dist/lib/webInitCommand.js

@@ -0,0 +1,167 @@
+export async function runWebInitCommand(getWebStorePath, opts) {
+    try {
+        const { mkdirSync } = await import("fs");
+        const { loadConfig, updateConfig, resolveTaskModel } = await import("./config.js");
+        const { createInterface } = await import("readline/promises");
+        const storePath = await getWebStorePath();
+        const DIM = "\x1b[2m";
+        const BOLD = "\x1b[1m";
+        const CYAN = "\x1b[36m";
+        const GREEN = "\x1b[32m";
+        const RESET = "\x1b[0m";
+        const CHECK = `${GREEN}\u2713${RESET}`;
+        let sitemapUrl = "";
+        let outputDir = opts.output;
+        let llmEnrich = true;
+        let envVarName = "ANTHROPIC_API_KEY";
+        // Detect current agent config for provider info
+        let agentProvider = "anthropic";
+        let agentModel = "";
+        try {
+            const cfg = await loadConfig(storePath);
+            agentProvider = cfg.llm.defaultProvider;
+            const taskModel = resolveTaskModel(cfg, "structuring");
+            agentModel = taskModel.model;
+        }
+        catch { /* no config yet */ }
+        // Map provider to env var name
+        const providerEnvVars = {
+            anthropic: "ANTHROPIC_API_KEY",
+            openai: "OPENAI_API_KEY",
+            groq: "GROQ_API_KEY",
+            xai: "XAI_API_KEY",
+            mistral: "MISTRAL_API_KEY",
+            ollama: "",
+            lmstudio: "",
+            custom: "GNOSYS_LLM_API_KEY",
+        };
+        if (!opts.nonInteractive && !opts.json && process.stdout.isTTY) {
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            try {
+                console.log();
+                console.log(`${BOLD}Web Knowledge Base Setup${RESET}`);
+                console.log();
+                console.log(`${DIM}This sets up a /knowledge/ directory in your project.`);
+                console.log(`Gnosys crawls your site, converts pages to markdown, and`);
+                console.log(`builds a search index. Everything deploys with your app.`);
+                console.log();
+                console.log(`No API keys are stored in your project. The LLM key is`);
+                console.log(`read from an environment variable at build time.${RESET}`);
+                console.log();
+                // Step 1: Sitemap URL
+                console.log(`${BOLD}Step 1/3${RESET} ${DIM}\u2014${RESET} Content source`);
+                console.log();
+                console.log(`${DIM}  \u2022 Deployed site:  https://yoursite.com/sitemap.xml`);
+                console.log(`  \u2022 Local dev:      http://localhost:3000/sitemap.xml`);
+                console.log(`  \u2022 Not ready yet:  press Enter (add later in gnosys.json)${RESET}`);
+                console.log();
+                const urlAnswer = await rl.question("Sitemap URL: ");
+                sitemapUrl = urlAnswer.trim();
+                console.log();
+                // Step 2: LLM enrichment
+                console.log(`${BOLD}Step 2/3${RESET} ${DIM}\u2014${RESET} LLM enrichment`);
+                console.log();
+                console.log(`${DIM}LLM enrichment generates better tags, keyword clouds, and`);
+                console.log(`frontmatter for each page. Without it, Gnosys uses TF-IDF`);
+                console.log(`keyword extraction (free, no API key needed, decent quality).${RESET}`);
+                console.log();
+                if (agentModel && providerEnvVars[agentProvider]) {
+                    console.log(`${DIM}Your agent setup uses ${agentProvider}/${agentModel} for structuring.${RESET}`);
+                }
+                console.log();
+                const enrichAnswer = await rl.question("Enable LLM enrichment? [Y/n] ");
+                llmEnrich = !enrichAnswer.trim().toLowerCase().startsWith("n");
+                console.log();
+                // Step 3: CI/CD env var
+                if (llmEnrich) {
+                    console.log(`${BOLD}Step 3/3${RESET} ${DIM}\u2014${RESET} CI/CD environment variable`);
+                    console.log();
+                    console.log(`${DIM}In CI/CD (GitHub Actions, Vercel, Netlify), the LLM API key`);
+                    console.log(`is read from an environment variable. No keys are stored in`);
+                    console.log(`your project or committed to git.${RESET}`);
+                    console.log();
+                    const defaultEnv = providerEnvVars[agentProvider] || "ANTHROPIC_API_KEY";
+                    const envAnswer = await rl.question(`Env var name for API key (${defaultEnv}): `);
+                    envVarName = envAnswer.trim() || defaultEnv;
+                }
+                else {
+                    console.log(`${DIM}Step 3/3 \u2014 Skipped (no LLM = no API key needed)${RESET}`);
+                    envVarName = "";
+                }
+                console.log();
+                // Output dir
+                const dirAnswer = await rl.question(`Output directory (${opts.output}): `);
+                outputDir = dirAnswer.trim() || opts.output;
+                rl.close();
+            }
+            catch {
+                rl.close();
+            }
+        }
+        // Create output directory
+        mkdirSync(outputDir, { recursive: true });
+        // Update gnosys.json with web config
+        if (opts.config) {
+            try {
+                const config = await loadConfig(storePath);
+                if (!config.web) {
+                    await updateConfig(storePath, {
+                        web: {
+                            source: opts.source,
+                            ...(sitemapUrl ? { sitemapUrl } : {}),
+                            outputDir,
+                            exclude: ["/api", "/admin", "/_next"],
+                            categories: {
+                                "/blog/*": "blog",
+                                "/services/*": "services",
+                                "/products/*": "products",
+                                "/about*": "company",
+                            },
+                            llmEnrich,
+                            prune: false,
+                        },
+                    });
+                }
+            }
+            catch {
+                // No gnosys.json yet — run gnosys init first
+            }
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, outputDir, source: opts.source, sitemapUrl: sitemapUrl || null, llmEnrich, envVarName: envVarName || null }));
+        }
+        else {
+            console.log(`${CHECK} Created ${outputDir}/`);
+            console.log(`${CHECK} Updated gnosys.json with web config`);
+            if (sitemapUrl) {
+                console.log(`${CHECK} Sitemap: ${sitemapUrl}`);
+            }
+            console.log(`${CHECK} LLM enrichment: ${llmEnrich ? "enabled" : "disabled (TF-IDF mode)"}`);
+            if (envVarName) {
+                console.log(`${CHECK} CI/CD env var: ${envVarName}`);
+            }
+            console.log();
+            console.log(`${BOLD}Next steps:${RESET}`);
+            if (!sitemapUrl) {
+                console.log(`  1. Add your sitemap URL to gnosys.json → web.sitemapUrl`);
+            }
+            if (envVarName) {
+                console.log(`  ${sitemapUrl ? "1" : "2"}. Set ${CYAN}${envVarName}${RESET} in your hosting provider (Vercel, Netlify, GitHub Actions)`);
+                console.log(`     ${DIM}Never commit API keys to your repo${RESET}`);
+            }
+            console.log(`  ${!sitemapUrl && envVarName ? "3" : envVarName || !sitemapUrl ? "2" : "1"}. Run: ${CYAN}gnosys web build${RESET}`);
+            console.log(`  ${!sitemapUrl && envVarName ? "4" : envVarName || !sitemapUrl ? "3" : "2"}. Add to package.json: ${CYAN}"postbuild": "npx gnosys web build"${RESET}`);
+            console.log();
+            console.log(`${DIM}Every deploy will re-crawl and rebuild the search index automatically.${RESET}`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Web init failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/webRemoveCommand.d.ts

@@ -0,0 +1,5 @@
+import type { GetWebStorePath } from "./webInitCommand.js";
+export type WebRemoveCommandOptions = {
+    json?: boolean;
+};
+export declare function runWebRemoveCommand(getWebStorePath: GetWebStorePath, filepath: string, opts: WebRemoveCommandOptions): Promise<void>;

package/dist/lib/webRemoveCommand.js

@@ -0,0 +1,41 @@
+import { existsSync } from "fs";
+import path from "path";
+export async function runWebRemoveCommand(getWebStorePath, filepath, opts) {
+    try {
+        const { loadConfig } = await import("./config.js");
+        const { buildIndex, writeIndex } = await import("./webIndex.js");
+        const fsp = await import("fs/promises");
+        const gnosysConfig = await loadConfig(await getWebStorePath());
+        const webConfig = gnosysConfig.web;
+        const knowledgeDir = webConfig?.outputDir || "./knowledge";
+        const knowledgeRoot = path.resolve(knowledgeDir);
+        const fullPath = path.resolve(knowledgeRoot, filepath);
+        const relativePath = path.relative(knowledgeRoot, fullPath);
+        if (path.isAbsolute(filepath) || relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            throw new Error(`Refusing to remove file outside knowledge directory: ${filepath}`);
+        }
+        if (!existsSync(fullPath)) {
+            throw new Error(`File not found: ${fullPath}`);
+        }
+        await fsp.unlink(fullPath);
+        // Rebuild index
+        const index = await buildIndex(knowledgeRoot);
+        await writeIndex(index, path.join(knowledgeRoot, "gnosys-index.json"));
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, removed: filepath, documentCount: index.documentCount }));
+        }
+        else {
+            console.log(`Removed: ${filepath}`);
+            console.log(`Index rebuilt: ${index.documentCount} documents`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Web remove failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/webStatusCommand.d.ts

@@ -0,0 +1,5 @@
+import type { GetWebStorePath } from "./webInitCommand.js";
+export type WebStatusCommandOptions = {
+    json?: boolean;
+};
+export declare function runWebStatusCommand(getWebStorePath: GetWebStorePath, opts: WebStatusCommandOptions): Promise<void>;

package/dist/lib/webStatusCommand.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+export async function runWebStatusCommand(getWebStorePath, opts) {
+    try {
+        const { loadConfig } = await import("./config.js");
+        const { readdirSync, statSync } = await import("fs");
+        const gnosysConfig = await loadConfig(await getWebStorePath());
+        const webConfig = gnosysConfig.web;
+        const knowledgeDir = webConfig?.outputDir || "./knowledge";
+        const resolvedDir = path.resolve(knowledgeDir);
+        if (!existsSync(resolvedDir)) {
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: true, exists: false, message: "Knowledge directory not found" }));
+            }
+            else {
+                console.log(`Knowledge directory not found: ${resolvedDir}`);
+                console.log(`Run 'gnosys web init' to get started.`);
+            }
+            return;
+        }
+        const categoryCounts = {};
+        let totalFiles = 0;
+        function countFiles(dir) {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    countFiles(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith(".md")) {
+                    const category = path.relative(resolvedDir, dir) || "root";
+                    categoryCounts[category] = (categoryCounts[category] || 0) + 1;
+                    totalFiles++;
+                }
+            }
+        }
+        countFiles(resolvedDir);
+        const indexPath = path.join(resolvedDir, "gnosys-index.json");
+        let indexInfo = { exists: false };
+        if (existsSync(indexPath)) {
+            const stat = statSync(indexPath);
+            try {
+                const indexData = JSON.parse(readFileSync(indexPath, "utf-8"));
+                indexInfo = {
+                    exists: true,
+                    documentCount: indexData.documentCount,
+                    size: stat.size,
+                    generated: indexData.generated,
+                };
+            }
+            catch {
+                indexInfo = { exists: true, size: stat.size };
+            }
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                knowledgeDir: resolvedDir,
+                totalFiles,
+                categoryCounts,
+                index: indexInfo,
+            }, null, 2));
+        }
+        else {
+            console.log(`Web Knowledge Base Status:`);
+            console.log(`  Directory: ${resolvedDir}`);
+            console.log(`  Total files: ${totalFiles}`);
+            if (Object.keys(categoryCounts).length > 0) {
+                console.log(`  By category:`);
+                for (const [cat, count] of Object.entries(categoryCounts).sort()) {
+                    console.log(`    ${cat}: ${count}`);
+                }
+            }
+            if (indexInfo.exists) {
+                console.log(`  Index: ${indexInfo.documentCount ?? "?"} docs, ${((indexInfo.size || 0) / 1024).toFixed(1)}KB`);
+                if (indexInfo.generated) {
+                    console.log(`  Last built: ${indexInfo.generated}`);
+                }
+            }
+            else {
+                console.log(`  Index: not built (run 'gnosys web build-index')`);
+            }
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Web status failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/webUpdateCommand.d.ts

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

package/dist/lib/webUpdateCommand.js

@@ -0,0 +1,72 @@
+import { existsSync } from "fs";
+import path from "path";
+export async function runWebUpdateCommand(getWebStorePath, urlOrPath, opts) {
+    try {
+        const { loadConfig } = await import("./config.js");
+        const { ingestUrl } = await import("./webIngest.js");
+        const { buildIndex, writeIndex } = await import("./webIndex.js");
+        const gnosysConfig = await loadConfig(await getWebStorePath());
+        const webConfig = gnosysConfig.web;
+        if (!webConfig) {
+            throw new Error("No web configuration found in gnosys.json. Run 'gnosys web init' first.");
+        }
+        const knowledgeDir = webConfig.outputDir || "./knowledge";
+        const knowledgeRoot = path.resolve(knowledgeDir);
+        const isUrl = urlOrPath.startsWith("http://") || urlOrPath.startsWith("https://");
+        if (isUrl) {
+            // Re-ingest the URL
+            const categories = opts.category
+                ? { "/*": opts.category }
+                : webConfig.categories;
+            const result = await ingestUrl(urlOrPath, {
+                source: "urls",
+                outputDir: knowledgeDir,
+                categories,
+                llmEnrich: opts.llm ? webConfig.llmEnrich : false,
+                prune: false,
+                concurrency: 1,
+                crawlDelayMs: 0,
+            }, gnosysConfig);
+            // Rebuild index
+            const index = await buildIndex(knowledgeRoot);
+            await writeIndex(index, path.join(knowledgeRoot, "gnosys-index.json"));
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: true, ...result, documentCount: index.documentCount }));
+            }
+            else {
+                console.log(`Updated: ${urlOrPath}`);
+                console.log(`  Added: ${result.added.length}, Updated: ${result.updated.length}`);
+                console.log(`Index rebuilt: ${index.documentCount} documents`);
+            }
+        }
+        else {
+            // Refresh a local knowledge file — rebuild index
+            const fullPath = path.resolve(knowledgeRoot, urlOrPath);
+            const relativePath = path.relative(knowledgeRoot, fullPath);
+            if (path.isAbsolute(urlOrPath) || relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+                throw new Error(`Refusing to refresh file outside knowledge directory: ${urlOrPath}`);
+            }
+            if (!existsSync(fullPath)) {
+                throw new Error(`File not found: ${fullPath}`);
+            }
+            const index = await buildIndex(knowledgeRoot);
+            await writeIndex(index, path.join(knowledgeRoot, "gnosys-index.json"));
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: true, refreshed: urlOrPath, documentCount: index.documentCount }));
+            }
+            else {
+                console.log(`Refreshed: ${urlOrPath}`);
+                console.log(`Index rebuilt: ${index.documentCount} documents`);
+            }
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Web update failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/workingSetCommand.d.ts

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

package/dist/lib/workingSetCommand.js

@@ -0,0 +1,37 @@
+import { GnosysDB } from "./db.js";
+export async function runWorkingSetCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exit(1);
+        }
+        const { getWorkingSet, formatWorkingSet, detectCurrentProject } = await import("./federated.js");
+        const pid = await detectCurrentProject(centralDb, opts.directory || undefined);
+        if (!pid) {
+            console.error("No project detected.");
+            process.exit(1);
+        }
+        const windowHours = parseInt(opts.window, 10);
+        const workingSet = getWorkingSet(centralDb, pid, { windowHours });
+        if (opts.json) {
+            console.log(JSON.stringify({
+                projectId: pid,
+                windowHours,
+                count: workingSet.length,
+                memories: workingSet.map((m) => ({ id: m.id, title: m.title, category: m.category, modified: m.modified })),
+            }, null, 2));
+        }
+        else {
+            console.log(formatWorkingSet(workingSet));
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnosys",
-  "version": "5.11.3",
+  "version": "5.12.0",
   "description": "Gnosys — Persistent Memory for AI Agents. Sandbox-first runtime, central SQLite brain, federated search, Dream Mode, Web Knowledge Base, Obsidian export.",
   "type": "module",
   "main": "dist/index.js",
@@ -21,6 +21,7 @@
   "scripts": {
     "prebuild": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "build": "tsc",
+    "postbuild": "node -e \"const fs=require('fs');for (const f of ['dist/cli.js','dist/index.js']) { try { fs.chmodSync(f,0o755); } catch {} }\"",
     "prebuild:publish": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "build:publish": "tsc -p tsconfig.publish.json",
     "start": "node dist/index.js",