gnosys 5.11.4 → 5.12.2

package/dist/lib/attachCommand.js

@@ -0,0 +1,66 @@
+/**
+ * CLI handlers for inline DB-blob attachments (v5.12).
+ *
+ *   gnosys attach <file> --memory <id>      store bytes inline on a memory
+ *   gnosys get-attachment <id> [--out path] retrieve the stored bytes
+ *
+ * Inline attachments live in the memory row, so they ride the normal sync
+ * rail to other machines and a remote/dockerized server.
+ */
+import { GnosysDB } from "./db.js";
+export async function runAttachCommand(filePath, opts) {
+    const db = GnosysDB.openCentral();
+    try {
+        if (!db.isAvailable()) {
+            console.error("Database not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const { attachFileToMemory } = await import("./attachments.js");
+        const result = await attachFileToMemory(db, opts.memory, filePath);
+        const sizeKb = (result.sizeBytes / 1024).toFixed(1);
+        const verb = result.unchanged ? "Already attached (no change)" : "Attached";
+        console.log(`${verb}: ${result.name} (${result.mime}, ${sizeKb} KB) → ${opts.memory}`);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+    }
+    finally {
+        db.close();
+    }
+}
+export async function runGetAttachmentCommand(memoryId, opts) {
+    const db = GnosysDB.openCentral();
+    try {
+        if (!db.isAvailable()) {
+            console.error("Database not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const { getMemoryAttachment } = await import("./attachments.js");
+        const att = getMemoryAttachment(db, memoryId);
+        if (!att) {
+            console.error(`No attachment found on memory: ${memoryId}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.out) {
+            const { writeFile } = await import("fs/promises");
+            await writeFile(opts.out, att.data);
+            console.log(`Wrote ${att.name} (${att.mime}, ${att.data.length} bytes) to ${opts.out}`);
+        }
+        else {
+            // No output path: print metadata + base64 so it can be piped/redirected.
+            console.error(`${att.name} (${att.mime}, ${att.data.length} bytes)`);
+            console.log(att.data.toString("base64"));
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/lib/attachments.d.ts

@@ -1,9 +1,15 @@
 /**
  * Gnosys Attachments — File attachment management for multimodal ingestion.
  *
- * Stores binary files in .gnosys/attachments/<uuid>.<ext> with a JSON manifest
- * at .gnosys/attachments/attachments.json for tracking metadata and memory links.
+ * Two storage modes:
+ *  - Filesystem (legacy, large media): bytes copied to .gnosys/attachments/<uuid>.<ext>
+ *    with a JSON manifest. Does NOT travel between machines.
+ *  - Inline DB blob (v5.12, small assets): bytes stored in the memory row's
+ *    attachment_data column. Travels over the same row-copy sync rail as
+ *    embeddings, so it works single-machine, multi-machine, and with a future
+ *    dockerized MCP without any shared volume.
  */
+import type { GnosysDB } from "./db.js";
 export interface AttachmentRecord {
     uuid: string;
     originalName: string;
@@ -14,6 +20,8 @@ export interface AttachmentRecord {
     createdAt: string;
     memoryIds: string[];
 }
+/** Infer a MIME type from a file path's extension. */
+export declare function inferMimeType(filePath: string): string;
 /**
  * Initialize the attachments directory and manifest in a store.
  * Safe to call multiple times — creates only if missing.
@@ -40,3 +48,36 @@ export declare function getAttachmentPath(storePath: string, uuid: string, ext:
  * tracks which memories reference it.
  */
 export declare function linkMemoryToAttachment(storePath: string, uuid: string, memoryId: string): Promise<void>;
+/**
+ * Maximum size for an inline DB-blob attachment. Larger files should use the
+ * filesystem path (`gnosys ingest`) so the synced central DB stays lean.
+ */
+export declare const MAX_INLINE_ATTACHMENT_BYTES: number;
+export interface InlineAttachment {
+    /** Raw file bytes. */
+    data: Buffer;
+    /** MIME type, e.g. "image/svg+xml". */
+    mime: string;
+    /** Original filename, e.g. "prospero-logo.svg". */
+    name: string;
+    /** Size in bytes. */
+    sizeBytes: number;
+}
+export interface AttachToMemoryResult {
+    memoryId: string;
+    name: string;
+    mime: string;
+    sizeBytes: number;
+    /** True when the file was identical to what was already attached (no write). */
+    unchanged: boolean;
+}
+/**
+ * Read a file and store its bytes inline on a memory row (attachment_data).
+ * Enforces the size cap and skips the write if the same bytes are already
+ * attached (content-hash dedup). Bumps `modified` so remote sync picks it up.
+ */
+export declare function attachFileToMemory(db: GnosysDB, memoryId: string, filePath: string): Promise<AttachToMemoryResult>;
+/** Return the inline attachment stored on a memory row, or null if none. */
+export declare function getMemoryAttachment(db: GnosysDB, memoryId: string): InlineAttachment | null;
+/** Remove an inline attachment from a memory row (keeps the memory itself). */
+export declare function detachFromMemory(db: GnosysDB, memoryId: string): boolean;

package/dist/lib/attachments.js

@@ -1,8 +1,13 @@
 /**
  * Gnosys Attachments — File attachment management for multimodal ingestion.
  *
- * Stores binary files in .gnosys/attachments/<uuid>.<ext> with a JSON manifest
- * at .gnosys/attachments/attachments.json for tracking metadata and memory links.
+ * Two storage modes:
+ *  - Filesystem (legacy, large media): bytes copied to .gnosys/attachments/<uuid>.<ext>
+ *    with a JSON manifest. Does NOT travel between machines.
+ *  - Inline DB blob (v5.12, small assets): bytes stored in the memory row's
+ *    attachment_data column. Travels over the same row-copy sync rail as
+ *    embeddings, so it works single-machine, multi-machine, and with a future
+ *    dockerized MCP without any shared volume.
  */
 import * as fs from "fs/promises";
 import * as path from "path";
@@ -37,6 +42,10 @@ const MIME_MAP = {
 function mimeFromExtension(ext) {
     return MIME_MAP[ext.toLowerCase()] || "application/octet-stream";
 }
+/** Infer a MIME type from a file path's extension. */
+export function inferMimeType(filePath) {
+    return mimeFromExtension(path.extname(filePath).slice(1));
+}
 // ─── Helpers ────────────────────────────────────────────────────────────
 function getAttachmentsDir(storePath) {
     return path.join(storePath, "attachments");
@@ -151,3 +160,73 @@ export async function linkMemoryToAttachment(storePath, uuid, memoryId) {
         await writeManifest(storePath, manifest);
     }
 }
+// ─── Inline DB-blob attachments (v5.12) ─────────────────────────────────
+//
+// Small binary assets (logos, diagrams, screenshots) are stored directly in
+// the memory row's attachment_data column. Because remote sync copies whole
+// rows (the same way it already moves the `embedding` blob), these attachments
+// travel machine-to-machine for free and need no shared filesystem — which is
+// exactly what a dockerized MCP server needs.
+/**
+ * Maximum size for an inline DB-blob attachment. Larger files should use the
+ * filesystem path (`gnosys ingest`) so the synced central DB stays lean.
+ */
+export const MAX_INLINE_ATTACHMENT_BYTES = 10 * 1024 * 1024; // 10 MB
+/**
+ * Read a file and store its bytes inline on a memory row (attachment_data).
+ * Enforces the size cap and skips the write if the same bytes are already
+ * attached (content-hash dedup). Bumps `modified` so remote sync picks it up.
+ */
+export async function attachFileToMemory(db, memoryId, filePath) {
+    const mem = db.getMemory(memoryId);
+    if (!mem) {
+        throw new Error(`Memory not found: ${memoryId}`);
+    }
+    const stat = await fs.stat(filePath);
+    if (stat.size > MAX_INLINE_ATTACHMENT_BYTES) {
+        const limitMb = (MAX_INLINE_ATTACHMENT_BYTES / (1024 * 1024)).toFixed(0);
+        const sizeMb = (stat.size / (1024 * 1024)).toFixed(1);
+        throw new Error(`File is ${sizeMb}MB, which exceeds the ${limitMb}MB inline-attachment limit. ` +
+            `Use 'gnosys ingest' for large media (it stores the file on disk instead).`);
+    }
+    const data = await fs.readFile(filePath);
+    const name = path.basename(filePath);
+    const mime = inferMimeType(filePath);
+    // Dedup: if the same bytes are already attached, skip the write.
+    if (mem.attachment_data && Buffer.from(mem.attachment_data).equals(data)) {
+        return { memoryId, name, mime, sizeBytes: data.length, unchanged: true };
+    }
+    db.updateMemory(memoryId, {
+        attachment_data: data,
+        attachment_mime: mime,
+        attachment_name: name,
+        modified: new Date().toISOString(),
+    });
+    return { memoryId, name, mime, sizeBytes: data.length, unchanged: false };
+}
+/** Return the inline attachment stored on a memory row, or null if none. */
+export function getMemoryAttachment(db, memoryId) {
+    const mem = db.getMemory(memoryId);
+    if (!mem?.attachment_data)
+        return null;
+    const data = Buffer.from(mem.attachment_data);
+    return {
+        data,
+        mime: mem.attachment_mime || "application/octet-stream",
+        name: mem.attachment_name || `${memoryId}.bin`,
+        sizeBytes: data.length,
+    };
+}
+/** Remove an inline attachment from a memory row (keeps the memory itself). */
+export function detachFromMemory(db, memoryId) {
+    const mem = db.getMemory(memoryId);
+    if (!mem?.attachment_data)
+        return false;
+    db.updateMemory(memoryId, {
+        attachment_data: null,
+        attachment_mime: null,
+        attachment_name: null,
+        modified: new Date().toISOString(),
+    });
+    return true;
+}

package/dist/lib/audioExtract.js

@@ -71,7 +71,10 @@ async function transcribeWithOpenAI(audioBuffer, fileName, mimeType, apiKey, opt
 async function transcribeWithLocal(filePath, options) {
     let pipeline;
     try {
-        // Dynamic import — @huggingface/transformers is an optional dependency
+        // Dynamic import — @huggingface/transformers is an optional dependency.
+        // Cast to any so TypeScript does not require the module's type declarations
+        // at compile time (the package is optional; CI and clean checkouts may not
+        // have it installed when running `tsc` / `npm run build`).
         const transformers = await import("@huggingface/transformers");
         pipeline = transformers.pipeline;
     }

package/dist/lib/auditCommand.d.ts

@@ -0,0 +1,7 @@
+export type AuditCommandOptions = {
+    days: string;
+    operation?: string;
+    limit?: string;
+    json?: boolean;
+};
+export declare function runAuditCommand(opts: AuditCommandOptions): Promise<void>;

package/dist/lib/auditCommand.js

@@ -0,0 +1,27 @@
+import { GnosysDB } from "./db.js";
+export async function runAuditCommand(opts) {
+    const { readAuditFromDb, formatAuditTimeline } = await import("./audit.js");
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB unavailable.");
+            process.exitCode = 1;
+            return;
+        }
+        const entries = readAuditFromDb(centralDb, {
+            days: parseInt(opts.days, 10),
+            operation: opts.operation,
+            limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(entries, null, 2));
+        }
+        else {
+            console.log(formatAuditTimeline(entries));
+        }
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/backupCommand.d.ts

@@ -0,0 +1,6 @@
+export type BackupCommandOptions = {
+    output?: string;
+    to?: string;
+    json?: boolean;
+};
+export declare function runBackupCommand(opts: BackupCommandOptions): Promise<void>;

package/dist/lib/backupCommand.js

@@ -0,0 +1,54 @@
+import { copyFileSync, existsSync } from "fs";
+import path from "path";
+import { GnosysDB } from "./db.js";
+export async function runBackupCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available (better-sqlite3 missing).");
+            process.exitCode = 1;
+            return;
+        }
+        const outputDir = opts.to || opts.output;
+        const backupPath = await centralDb.backup(outputDir);
+        const counts = centralDb.getMemoryCount();
+        const projectCount = centralDb.getAllProjects().length;
+        const centralDir = GnosysDB.getCentralDbDir();
+        const copiedFiles = [backupPath];
+        const backupDir = path.dirname(backupPath);
+        const sandboxLog = path.join(centralDir, "sandbox", "sandbox.log");
+        if (existsSync(sandboxLog)) {
+            const logDest = path.join(backupDir, "sandbox.log.bak");
+            copyFileSync(sandboxLog, logDest);
+            copiedFiles.push(logDest);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true, backupPath, memories: counts.total,
+                active: counts.active, archived: counts.archived,
+                projects: projectCount, files: copiedFiles,
+            }));
+        }
+        else {
+            console.log(`Backup created: ${backupPath}`);
+            console.log(`  Memories: ${counts.total} (${counts.active} active, ${counts.archived} archived)`);
+            console.log(`  Projects: ${projectCount}`);
+            if (copiedFiles.length > 1)
+                console.log(`  Additional files: ${copiedFiles.length - 1}`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Backup failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/bootstrapCommand.d.ts

@@ -0,0 +1,15 @@
+import type { GnosysResolver } from "./resolver.js";
+export type BootstrapCommandOptions = {
+    pattern?: string[];
+    skipExisting?: boolean;
+    category: string;
+    author: string;
+    authority: string;
+    confidence: string;
+    preserveFrontmatter?: boolean;
+    dryRun?: boolean;
+    store?: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runBootstrapCommand(getResolver: GetResolver, sourceDir: string, opts: BootstrapCommandOptions): Promise<void>;
+export {};

package/dist/lib/bootstrapCommand.js

@@ -0,0 +1,51 @@
+export async function runBootstrapCommand(getResolver, sourceDir, opts) {
+    const resolver = await getResolver();
+    const writeTarget = resolver.getWriteTarget(opts.store || undefined);
+    if (!writeTarget) {
+        console.error("No writable store found.");
+        process.exit(1);
+    }
+    // Show what we'll scan
+    const { bootstrap, discoverFiles } = await import("./bootstrap.js");
+    const files = await discoverFiles(sourceDir, opts.pattern);
+    console.log(`Found ${files.length} files in ${sourceDir}\n`);
+    if (files.length === 0) {
+        console.log("Nothing to import.");
+        return;
+    }
+    const result = await bootstrap(writeTarget.store, {
+        sourceDir,
+        patterns: opts.pattern,
+        skipExisting: opts.skipExisting,
+        defaultCategory: opts.category,
+        defaultAuthor: opts.author,
+        defaultAuthority: opts.authority,
+        defaultConfidence: parseFloat(opts.confidence),
+        preserveFrontmatter: opts.preserveFrontmatter,
+        dryRun: opts.dryRun,
+    });
+    const mode = opts.dryRun ? "DRY RUN" : "COMPLETE";
+    console.log(`\nBootstrap ${mode}:`);
+    console.log(`  Scanned: ${result.totalScanned}`);
+    console.log(`  ${opts.dryRun ? "Would import" : "Imported"}: ${result.imported.length}`);
+    console.log(`  Skipped: ${result.skipped.length}`);
+    console.log(`  Failed: ${result.failed.length}`);
+    if (result.imported.length > 0) {
+        console.log(`\n${opts.dryRun ? "Would import" : "Imported"}:`);
+        for (const f of result.imported) {
+            console.log(`  + ${f}`);
+        }
+    }
+    if (result.skipped.length > 0) {
+        console.log(`\nSkipped (already exist):`);
+        for (const f of result.skipped) {
+            console.log(`  ⏭ ${f}`);
+        }
+    }
+    if (result.failed.length > 0) {
+        console.log(`\nFailed:`);
+        for (const f of result.failed) {
+            console.log(`  ❌ ${f.path}: ${f.error}`);
+        }
+    }
+}

package/dist/lib/briefingCommand.d.ts

@@ -0,0 +1,7 @@
+export type BriefingCommandOptions = {
+    project?: string;
+    all?: boolean;
+    directory?: string;
+    json: boolean;
+};
+export declare function runBriefingCommand(projectNameOrId: string | undefined, opts: BriefingCommandOptions): Promise<void>;

package/dist/lib/briefingCommand.js

@@ -0,0 +1,92 @@
+import { GnosysDB } from "./db.js";
+export async function runBriefingCommand(projectNameOrId, opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const { generateBriefing, generateAllBriefings, detectCurrentProject } = await import("./federated.js");
+        if (opts.all) {
+            const briefings = generateAllBriefings(centralDb);
+            if (opts.json) {
+                console.log(JSON.stringify({ count: briefings.length, briefings }, null, 2));
+            }
+            else {
+                if (briefings.length === 0) {
+                    console.log("No projects registered.");
+                    return;
+                }
+                for (const b of briefings) {
+                    console.log(`\n## ${b.projectName}`);
+                    console.log(b.summary);
+                }
+            }
+            return;
+        }
+        // v5.7.0: accept project name as positional argument in addition to --project <id>.
+        // Resolution order: positional name → --project flag → cwd auto-detect.
+        let pid = opts.project ?? null;
+        if (!pid && projectNameOrId) {
+            const byId = centralDb.getProject(projectNameOrId);
+            if (byId) {
+                pid = byId.id;
+            }
+            else {
+                const all = centralDb.getAllProjects();
+                const byName = all.find((p) => p.name === projectNameOrId);
+                if (byName)
+                    pid = byName.id;
+            }
+            if (!pid) {
+                console.error(`Project not found: "${projectNameOrId}". Run 'gnosys projects' to list registered projects.`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (!pid)
+            pid = await detectCurrentProject(centralDb, opts.directory || undefined);
+        if (!pid) {
+            console.error("No project specified and none detected.");
+            process.exitCode = 1;
+            return;
+        }
+        const briefing = generateBriefing(centralDb, pid);
+        if (!briefing) {
+            console.error(`Project not found: ${pid}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(briefing, null, 2));
+        }
+        else {
+            console.log(`# Briefing: ${briefing.projectName}`);
+            console.log(`Directory: ${briefing.workingDirectory}`);
+            console.log(`Active memories: ${briefing.activeMemories} / ${briefing.totalMemories}`);
+            console.log(`\nCategories:`);
+            for (const [cat, count] of Object.entries(briefing.categories).sort((a, b) => b[1] - a[1])) {
+                console.log(`  ${cat}: ${count}`);
+            }
+            console.log(`\nRecent activity (7d):`);
+            if (briefing.recentActivity.length === 0) {
+                console.log("  None");
+            }
+            for (const r of briefing.recentActivity) {
+                console.log(`  - ${r.title} (${r.modified})`);
+            }
+            console.log(`\nTop tags: ${briefing.topTags.slice(0, 10).map((t) => `${t.tag}(${t.count})`).join(", ") || "None"}`);
+            console.log(`\n${briefing.summary}`);
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/centralizeCommand.d.ts

@@ -0,0 +1,5 @@
+export type CentralizeCommandOptions = {
+    to: string;
+    force?: boolean;
+};
+export declare function runCentralizeCommand(opts: CentralizeCommandOptions): Promise<void>;

package/dist/lib/centralizeCommand.js

@@ -0,0 +1,16 @@
+import { centralizeDb } from "./centralize.js";
+export async function runCentralizeCommand(opts) {
+    try {
+        const r = await centralizeDb({ to: opts.to, force: opts.force });
+        const mb = (r.bytes / 1024 / 1024).toFixed(1);
+        console.log("✓ Seeded central brain:");
+        console.log(`  from: ${r.source}`);
+        console.log(`  to:   ${r.target} (${mb} MB)`);
+        console.log("");
+        console.log(`Run the server against it with GNOSYS_HOME=${opts.to}, or mount this dir as the container's /data volume.`);
+    }
+    catch (e) {
+        console.error(`centralize failed: ${e instanceof Error ? e.message : e}`);
+        process.exitCode = 1;
+    }
+}

package/dist/lib/chat/choose.js

@@ -115,7 +115,7 @@ export function parseChooseYaml(yaml) {
         const itemStart = line.match(/^\s*-\s*id:\s*(.+?)\s*$/);
         if (itemStart) {
             // Push previous item if any
-            if (current && current.label)
+            if (current?.label)
                 options.push(current);
             current = { id: itemStart[1], label: "" };
             continue;
@@ -133,7 +133,7 @@ export function parseChooseYaml(yaml) {
         }
     }
     // Flush the last option
-    if (current && current.label)
+    if (current?.label)
         options.push(current);
     return { prompt, options };
 }

package/dist/lib/chatCommand.d.ts

@@ -0,0 +1,12 @@
+import type { GnosysResolver } from "./resolver.js";
+export type ChatCommandOptions = {
+    resume?: string;
+    list?: boolean;
+    search?: string;
+    provider?: string;
+    model?: string;
+    limit: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runChatCommand(getResolver: GetResolver, opts: ChatCommandOptions): Promise<void>;
+export {};

package/dist/lib/chatCommand.js

@@ -0,0 +1,46 @@
+import { DEFAULT_CONFIG, loadConfig, resolveTaskModel, } from "./config.js";
+export async function runChatCommand(getResolver, opts) {
+    const limit = parseInt(opts.limit, 10) || 20;
+    const chat = await import("./chat/index.js");
+    if (opts.list) {
+        chat.printSessionList(limit);
+        return;
+    }
+    if (opts.search) {
+        chat.printSearchResults(opts.search, limit);
+        return;
+    }
+    const resolver = await getResolver();
+    const stores = resolver.getStores();
+    const storePath = stores[0]?.path ?? process.cwd();
+    let cliConfig;
+    try {
+        cliConfig = await loadConfig(storePath);
+    }
+    catch {
+        cliConfig = DEFAULT_CONFIG;
+    }
+    // Fail-fast on missing API key before TUI render.
+    {
+        const chatTask = resolveTaskModel(cliConfig, "chat");
+        const provider = opts.provider ?? chatTask.provider;
+        if (provider !== "ollama" && provider !== "lmstudio") {
+            const { getApiKeyForProvider } = await import("./setup.js");
+            const key = await getApiKeyForProvider(provider);
+            if (!key) {
+                const { Status } = await import("./setup/ui/status.js");
+                const envVar = `${provider.toUpperCase()}_API_KEY`;
+                process.stderr.write(`${Status("fail", `no API key for ${provider} (the configured chat provider)`)}\n`);
+                process.stderr.write(`   fix:  gnosys setup           pick a provider with a key, or add one\n`);
+                process.stderr.write(`         export ${envVar}=...\n`);
+                process.exit(1);
+            }
+        }
+    }
+    await chat.startChat({
+        config: cliConfig,
+        resume: opts.resume,
+        providerName: opts.provider,
+        modelName: opts.model,
+    });
+}

package/dist/lib/checkCommand.d.ts

@@ -0,0 +1,4 @@
+export type CheckCommandOptions = {
+    task?: string;
+};
+export declare function runCheckCommand(opts: CheckCommandOptions): Promise<void>;