@hraness/sponge 0.2.5 → 0.3.0

package/dist/src/cli/config.js

@@ -1,8 +1,8 @@
 import { lstat } from 'node:fs/promises';
 import { readConfined } from '../acquisition/files.js';
 import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import { InputError } from '../app/source.js';
+import { sha256 } from '../util/hash.js';
+import { SpongeError } from '../errors.js';
 /** Local references only. Tokens, cookies and passwords never belong in this file. */
 export async function readConnections(root) {
     const path = join(root, 'connections.json');
@@ -10,7 +10,7 @@ export async function readConnections(root) {
     try {
         const stat = await lstat(path);
         if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 65536 || (stat.mode & 0o077) !== 0)
-            throw new InputError();
+            throw new SpongeError('invalid-input');
         bytes = await readConfined(root, 'connections.json', 65536);
     }
     catch (error) {
@@ -23,23 +23,26 @@ export async function readConnections(root) {
         config = JSON.parse(bytes.toString('utf8'));
     }
     catch {
-        throw new InputError();
+        throw new SpongeError('invalid-input');
     }
     if (config?.schemaVersion !== 1 || !Array.isArray(config.connections) || config.connections.length > 100)
-        throw new InputError();
+        throw new SpongeError('invalid-input');
     const ids = new Set();
     return config.connections.map((entry) => {
         if (!entry || typeof entry.id !== 'string' || !/^[a-zA-Z0-9_-]{1,64}$/.test(entry.id) || ids.has(entry.id))
-            throw new InputError();
+            throw new SpongeError('invalid-input');
         ids.add(entry.id);
         let capture;
-        if (entry.kind === 'account' && typeof entry.stateHome === 'string' && entry.stateHome.startsWith('/') && typeof entry.accountId === 'string')
+        if (entry.kind === 'account' &&
+            typeof entry.stateHome === 'string' &&
+            entry.stateHome.startsWith('/') &&
+            typeof entry.accountId === 'string')
             capture = { kind: 'account', stateHome: entry.stateHome, accountId: entry.accountId };
         else if (entry.kind === 'cdp' && typeof entry.endpoint === 'string')
             capture = { kind: 'cdp', endpoint: entry.endpoint };
         else
-            throw new InputError();
-        const realm = 'connection:' + createHash('sha256').update(JSON.stringify([entry.id, capture])).digest('hex');
+            throw new SpongeError('invalid-input');
+        const realm = 'connection:' + sha256(JSON.stringify([entry.id, capture]));
         return { id: entry.id, realm, capture };
     });
 }

package/dist/src/cli/digest.d.ts

@@ -1,4 +1,4 @@
-import type { Derivation, DigestReview } from '../store/foundation.js';
+import type { Derivation, DigestReview } from '../digest/derivation.js';
 /** Review targets: `all`, `gist`, `idea:N` or `quote:N.M` (0-based), comma-separated. */
 export declare const reviewSpec: RegExp;
 /**

package/dist/src/cli/digest.js

@@ -1,4 +1,4 @@
-import { InputError } from '../app/source.js';
+import { SpongeError } from '../errors.js';
 /** Review targets: `all`, `gist`, `idea:N` or `quote:N.M` (0-based), comma-separated. */
 export const reviewSpec = /^(?:all|gist|idea:\d{1,2}|quote:\d{1,2}\.\d)(?:,(?:all|gist|idea:\d{1,2}|quote:\d{1,2}\.\d)){0,63}$/;
 /**
@@ -7,19 +7,27 @@ export const reviewSpec = /^(?:all|gist|idea:\d{1,2}|quote:\d{1,2}\.\d)(?:,(?:al
  */
 export function reviewFromSpec(d, accept, reject) {
     if (accept === undefined && reject === undefined)
-        throw new InputError();
-    const ideas = d.output.ideas, review = { gist: d.review.gist, ideas: ideas.map((_, i) => d.review.ideas?.[i] ?? null), quotes: ideas.map((idea, i) => idea.quotes.map((_, j) => d.review.quotes?.[i]?.[j] ?? null)) };
-    const parse = (spec) => { if (spec === undefined)
-        return []; if (!reviewSpec.test(spec))
-        throw new InputError(); return [...new Set(spec.split(','))]; };
+        throw new SpongeError('invalid-input');
+    const ideas = d.output.ideas, review = {
+        gist: d.review.gist,
+        ideas: ideas.map((_, i) => d.review.ideas?.[i] ?? null),
+        quotes: ideas.map((idea, i) => idea.quotes.map((_, j) => d.review.quotes?.[i]?.[j] ?? null)),
+    };
+    const parse = (spec) => {
+        if (spec === undefined)
+            return [];
+        if (!reviewSpec.test(spec))
+            throw new SpongeError('invalid-input');
+        return [...new Set(spec.split(','))];
+    };
     const a = parse(accept), r = parse(reject);
-    if (a.some(t => r.includes(t)))
-        throw new InputError();
+    if (a.some((t) => r.includes(t)))
+        throw new SpongeError('invalid-input');
     const set = (target, status) => {
         if (target === 'all') {
             review.gist = status;
             review.ideas = review.ideas.map(() => status);
-            review.quotes = review.quotes.map(q => q.map(() => status));
+            review.quotes = review.quotes.map((q) => q.map(() => status));
             return;
         }
         if (target === 'gist') {
@@ -28,20 +36,26 @@ export function reviewFromSpec(d, accept, reject) {
         }
         const [, kind, i, j] = /^(idea|quote):(\d+)(?:\.(\d+))?$/.exec(target), n = Number(i);
         if (n >= ideas.length)
-            throw new InputError();
+            throw new SpongeError('invalid-input');
         if (kind === 'idea') {
             review.ideas[n] = status;
             return;
         }
         if (Number(j) >= ideas[n].quotes.length)
-            throw new InputError();
+            throw new SpongeError('invalid-input');
         review.quotes[n][Number(j)] = status;
     };
-    for (const [targets, status] of [[a, 'accepted'], [r, 'rejected']])
+    for (const [targets, status] of [
+        [a, 'accepted'],
+        [r, 'rejected'],
+    ])
         for (const t of targets)
             if (t === 'all')
                 set(t, status);
-    for (const [targets, status] of [[a, 'accepted'], [r, 'rejected']])
+    for (const [targets, status] of [
+        [a, 'accepted'],
+        [r, 'rejected'],
+    ])
         for (const t of targets)
             if (t !== 'all')
                 set(t, status);
@@ -51,13 +65,21 @@ const mark = (s) => s === 'accepted' ? '[accepted]' : s === 'rejected' ? '[rejec
 /** Plain-text digest with the review targets `sponge review` accepts. */
 export function digestText(d) {
     const o = d.output, producer = d.producer;
-    const lines = [`Digest ${d.id} (${o.form}${producer?.model?.model ? `, ${producer.model.model}` : ''}${producer?.promptVersion ? `, ${producer.promptVersion}` : ''})`, '', `gist ${mark(d.review.gist)} ${o.gist.lead}`];
+    const lines = [
+        `Digest ${d.id} (${o.form}${producer?.model?.model ? `, ${producer.model.model}` : ''}${producer?.promptVersion ? `, ${producer.promptVersion}` : ''})`,
+        '',
+        `gist ${mark(d.review.gist)} ${o.gist.lead}`,
+    ];
     if (o.gist.context)
         lines.push(`  ${o.gist.context}`);
     o.ideas.forEach((idea, i) => {
-        lines.push('', `idea:${i} ${mark(d.review.ideas?.[i])} ${idea.claim}`, `  ${idea.kind}; ${idea.voice.type === 'author' ? 'author' : `${idea.voice.type}: ${idea.voice.name}`}`, `  ${idea.detail}`);
-        idea.quotes.forEach((q, j) => lines.push(`  quote:${i}.${j} ${mark(d.review.quotes?.[i]?.[j])} “${q.text.replace(/\s+/g, ' ')}”${q.speaker ? ` (${q.speaker})` : ''}`));
+        lines.push('', `idea:${i} ${mark(d.review.ideas?.[i])} ${idea.claim}`, ...(idea.kind || idea.voice
+            ? [
+                `  ${[idea.kind, idea.voice && (idea.voice.type === 'author' ? 'author' : `${idea.voice.type}: ${idea.voice.name}`)].filter(Boolean).join('; ')}`,
+            ]
+            : []), `  ${idea.detail}`);
+        idea.quotes.forEach((q, j) => lines.push(`  quote:${i}.${j} ${mark(d.review.quotes?.[i]?.[j])} “${q.text.replace(/\s+/g, ' ')}”${(q.attribution ?? q.speaker) ? ` (${q.attribution ?? q.speaker})` : ''}`));
     });
-    lines.push('', `Tags: ${o.tags.join(', ')}`);
+    lines.push('', `Tags: ${o.tags.join(', ') || 'none'}`);
     return lines.join('\n');
 }

package/dist/src/cli/import.js

@@ -2,12 +2,33 @@ import { importManifest } from '../importers/apply.js';
 import { releasedBundleVerifier } from '../importers/inspect.js';
 import { importJungle } from '../importers/jungle.js';
 /** A source manifest is explicit; default execution produces a private dry-run report. */
-export function importAction(store, path, options) { return importManifest(store, path, options); }
+export function importAction(store, path, options) {
+    return importManifest(store, path, options);
+}
 /** Jungle is read in place; only an applied import needs the capture runtime, to reverify each bundle. */
 export function jungleAction(store, path, options) {
-    return importJungle(store, path, { dryRun: options.dryRun, limit: options.limit, offset: options.offset, ...(options.signal ? { signal: options.signal } : {}), ...(options.runtime ? { verify: releasedBundleVerifier(options.runtime, store.root, options.signal) } : {}) });
+    return importJungle(store, path, {
+        dryRun: options.dryRun,
+        limit: options.limit,
+        offset: options.offset,
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(options.runtime ? { verify: releasedBundleVerifier(options.runtime, store.root, options.signal) } : {}),
+    });
 }
-const tally = (m) => Object.entries(m).sort().map(([k, n]) => `${k} ${n}`).join(', ') || 'none';
+const tally = (m) => Object.entries(m)
+    .sort()
+    .map(([k, n]) => `${k} ${n}`)
+    .join(', ') || 'none';
 export function jungleText(r) {
-    return [`Jungle ${r.dryRun ? 'dry run (captures verified on --apply)' : 'import'}: ${r.entries.length} of ${r.notes} notes`, `Items: ${r.counts.newItems} new, ${r.counts.existingItems} existing`, `Editorial: ${tally(r.counts.editorial)}`, `Digest v1: ${tally(r.counts.v1)}`, `Visibility: ${tally(r.counts.visibility)}`, `Skipped: ${tally(r.counts.skipped)}`, ...(r.nextOffset !== null ? [`Next offset: ${r.nextOffset}`] : [])].join('\n');
+    return [
+        `Jungle ${r.dryRun ? 'dry run (captures verified on --apply)' : 'import'}: ${r.entries.length} of ${r.notes} notes`,
+        `Items: ${r.counts.newItems} new, ${r.counts.existingItems} existing`,
+        `Editorial: ${tally(r.counts.editorial)}`,
+        `Digest v2: ${tally(r.counts.digest)}`,
+        ...(Object.keys(r.counts.digestIssues).length ? [`Not convertible because: ${tally(r.counts.digestIssues)}`] : []),
+        `Quotes: ${r.counts.quotes.assigned} assigned, dropped ${tally(r.counts.quotes.dropped)}`,
+        `Visibility: ${tally(r.counts.visibility)}`,
+        `Skipped: ${tally(r.counts.skipped)}`,
+        ...(r.nextOffset !== null ? [`Next offset: ${r.nextOffset}`] : []),
+    ].join('\n');
 }

package/dist/src/cli/indexing.d.ts

@@ -8,3 +8,5 @@ export declare function indexAction(store: LibraryStore, action: string, id: str
     dryRun?: boolean;
     vacuum?: boolean;
 }): Promise<Record<string, unknown>>;
+/** `index status` with no generation: the active one's coverage and what is still to embed. */
+export declare function overviewText(result: ReturnType<LibraryStore['index']['overview']>): string;

package/dist/src/cli/indexing.js

@@ -1,24 +1,41 @@
 import { indexSpace } from '../inference/embedding/index.js';
 import { drainIndexQueue } from '../indexing/runner.js';
-import { StoreError } from '../store/index.js';
-import { NativeCatalogError } from '../models/catalog.js';
 import { pruneIndex } from '../indexing/prune-run.js';
+import { SpongeError } from '../errors.js';
 export async function indexAction(store, action, id, options = {}) {
     if (action === 'status')
-        return { generation: store.indexStatus(id) };
+        return id ? { generation: store.index.status(id) } : store.index.overview(options.profile);
     if (action === 'rollback') {
-        const generation = store.indexStatus(id);
+        const generation = store.index.status(id);
         if (!['active', 'retired'].includes(generation.state))
-            throw new StoreError('invalid-input');
-        return { generation: store.activateIndex(id) };
+            throw new SpongeError('invalid-input');
+        return { generation: store.index.activate(id) };
     }
     if (action === 'prune')
         return { prune: await pruneIndex(store, { keep: options.keep, dryRun: options.dryRun, vacuum: options.vacuum }) };
     if (!options.runtime)
-        throw new NativeCatalogError('runtime-missing');
+        throw new SpongeError('runtime-missing');
     if (action === 'create') {
-        const space = indexSpace(options.runtime.helperSha256), generation = store.createIndexGeneration({ profileId: options.profile ?? 'default', fingerprint: space.fingerprint, identity: space.identity, dimensions: space.dimensions });
-        return { generation, job: store.submitIndexJob(generation.id) };
+        const space = indexSpace(options.runtime.helperSha256), generation = store.index.create({
+            profileId: options.profile ?? 'default',
+            fingerprint: space.fingerprint,
+            identity: space.identity,
+            dimensions: space.dimensions,
+        });
+        return { generation, job: store.index.submitJob(generation.id) };
     }
     return { results: await drainIndexQueue(store, { runtime: options.runtime, signal: options.signal }) };
 }
+/** `index status` with no generation: the active one's coverage and what is still to embed. */
+export function overviewText(result) {
+    const { generation: g, job } = result;
+    if (!g)
+        return 'No active index. Run sponge index create, then sponge index run.';
+    return [
+        `Active generation: ${g.id} (${g.profileId})`,
+        `Items: ${g.items}`,
+        `Chunks and images: ${g.completed} of ${g.expected} embedded, ${g.pending} pending`,
+        `Job: ${job ? `${job.id} ${job.state}${job.reason ? ` (${job.reason})` : ''}` : 'none'}`,
+        ...(g.pending ? ['Run sponge index run (or let the worker) to embed only the pending ones.'] : []),
+    ].join('\n');
+}