@relvehq/agent-ready 0.0.0-stage → 0.3.0

package/dist/refine/run.d.ts

@@ -0,0 +1,52 @@
+import { type RefineResult } from "./refine";
+import { type PageTypeRules, type RefinePrompt } from "./prompts";
+import type { CheckOptions } from "./check";
+import type { ModelClient } from "./model";
+export interface StoredDoc {
+    path: string;
+    url: string;
+    markdown: string;
+    sourceHash: string;
+    promptId: string;
+    generatedAt: string;
+    tokens: number;
+}
+export interface RefineStore {
+    /** The fingerprint the stored doc was written from, or null. */
+    lastHash(path: string): Promise<string | null>;
+    save(doc: StoredDoc): Promise<void>;
+}
+export interface RunOptions extends CheckOptions {
+    /** Public origin, e.g. "https://relvehq.com". */
+    site: string;
+    paths: string[];
+    /** Prompts by page type (promptsByType). */
+    prompts: Record<string, RefinePrompt>;
+    pageTypes?: PageTypeRules;
+    model: ModelClient;
+    store: RefineStore;
+    /** Refine even when the fingerprint is unchanged. */
+    force?: boolean;
+    /** Pages at a time. Default 2. */
+    concurrency?: number;
+    retries?: number;
+    fetch?: typeof fetch;
+    now?: () => Date;
+    siteName?: string;
+    onResult?: (r: RunItem) => void;
+}
+export interface RunItem extends Partial<Omit<RefineResult, "status">> {
+    path: string;
+    status: RefineResult["status"] | "no-prompt";
+    promptId: string | null;
+    saved: boolean;
+}
+export interface RunReport {
+    items: RunItem[];
+    counts: Record<RunItem["status"], number>;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export declare function runRefine(opts: RunOptions): Promise<RunReport>;

package/dist/refine/run.js

@@ -0,0 +1,66 @@
+"use strict";
+// Refine, step 5: the runner. Refines a list of pages, skips pages whose
+// fingerprint hasn't changed ("stay fresh"), saves what passes the check.
+//
+//   await runRefine({ site, paths, prompts, model, store })
+//
+// The store is anything with lastHash() and save(): the file store
+// (refine/file-store.ts), a database, a test double.
+// NODE ONLY (through refinePage).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRefine = runRefine;
+const refine_1 = require("./refine");
+const prompts_1 = require("./prompts");
+async function runRefine(opts) {
+    const site = opts.site.replace(/\/+$/, "");
+    const items = new Array(opts.paths.length);
+    let next = 0;
+    const one = async (path) => {
+        const prompt = (0, prompts_1.promptFor)(path, opts.prompts, opts.pageTypes);
+        if (!prompt)
+            return { path, status: "no-prompt", promptId: null, saved: false };
+        const previousHash = opts.force ? null : await opts.store.lastHash(path);
+        const r = await (0, refine_1.refinePage)({
+            url: site + path,
+            prompt,
+            model: opts.model,
+            previousHash,
+            retries: opts.retries,
+            fetch: opts.fetch,
+            now: opts.now,
+            siteName: opts.siteName,
+            countTokens: opts.countTokens,
+        });
+        let saved = false;
+        if (r.status === "ok" && r.doc && r.input && r.generatedAt) {
+            await opts.store.save({
+                path,
+                url: r.url,
+                markdown: r.doc,
+                sourceHash: r.input.sourceHash,
+                promptId: prompt.id,
+                generatedAt: r.generatedAt,
+                tokens: r.tokens ?? 0,
+            });
+            saved = true;
+        }
+        return { ...r, path, promptId: prompt.id, saved };
+    };
+    const worker = async () => {
+        while (next < opts.paths.length) {
+            const i = next++;
+            const item = await one(opts.paths[i]);
+            items[i] = item;
+            opts.onResult?.(item);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.max(1, Math.min(opts.concurrency ?? 2, opts.paths.length)) }, worker));
+    const counts = { ok: 0, unchanged: 0, rejected: 0, error: 0, "no-prompt": 0 };
+    const usage = { inputTokens: 0, outputTokens: 0 };
+    for (const it of items) {
+        counts[it.status]++;
+        usage.inputTokens += it.usage?.inputTokens ?? 0;
+        usage.outputTokens += it.usage?.outputTokens ?? 0;
+    }
+    return { items, counts, usage };
+}

package/dist/refine/types.d.ts

@@ -0,0 +1,17 @@
+export interface PageLink {
+    url: string;
+    text: string;
+}
+/** The model's input for one page (see refine/extract.ts). */
+export interface PageInput {
+    /** Absolute page URL. */
+    url: string;
+    text: string;
+    links: PageLink[];
+    jsonLd: unknown[];
+    /** SHA-256 hex of `text + "\n" + JSON.stringify(jsonLd)`. */
+    sourceHash: string;
+    mainSource: "main" | "article" | "body";
+}
+/** Links as the prompt's {{PAGE_LINKS}} block: "url | text" per line. */
+export declare function formatLinks(links: PageLink[]): string;

package/dist/refine/types.js

@@ -0,0 +1,8 @@
+"use strict";
+// Shared shapes for refine. EDGE-SAFE (no imports).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLinks = formatLinks;
+/** Links as the prompt's {{PAGE_LINKS}} block: "url | text" per line. */
+function formatLinks(links) {
+    return links.map((l) => (l.text ? `${l.url} | ${l.text}` : l.url)).join("\n");
+}