@xfey/tutti 0.1.0

package/dist/project-brief/repository.d.ts

@@ -0,0 +1,5 @@
+import type { SqliteDatabase } from "../store/index.js";
+import type { ProjectBriefProjection, ProjectBriefSourceDocument, UpsertProjectBriefInput } from "./types.js";
+export declare function readProjectBriefProjection(db: SqliteDatabase, currentSources?: ProjectBriefSourceDocument[]): ProjectBriefProjection;
+export declare function upsertProjectBriefProjection(db: SqliteDatabase, input: UpsertProjectBriefInput): ProjectBriefProjection;
+//# sourceMappingURL=repository.d.ts.map

package/dist/project-brief/repository.js

@@ -0,0 +1,97 @@
+import { projectBriefSourceFingerprints, } from "./source.js";
+function parseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+function stringifyJson(value) {
+    return JSON.stringify(value);
+}
+function nowIso(now) {
+    return (now ?? (() => new Date()))().toISOString();
+}
+function sourceDocsEqual(left, right) {
+    return stringifyJson(left) === stringifyJson(right);
+}
+function mapProjectBriefRow(row) {
+    const record = {
+        product_summary: row.product_summary,
+        tech_summary: row.tech_summary,
+        structure_summary: row.structure_summary,
+        principles_summary: row.principles_summary,
+        source_docs: parseJson(row.source_docs_json, []),
+        updated_at: row.updated_at,
+    };
+    if (row.updated_by_activity_ref !== null) {
+        record.updated_by_activity_ref = row.updated_by_activity_ref;
+    }
+    if (row.updated_by_workflow_ref !== null) {
+        record.updated_by_workflow_ref = row.updated_by_workflow_ref;
+    }
+    return record;
+}
+export function readProjectBriefProjection(db, currentSources) {
+    const row = db
+        .prepare(`
+        SELECT
+          product_summary,
+          tech_summary,
+          structure_summary,
+          principles_summary,
+          source_docs_json,
+          updated_by_activity_ref,
+          updated_by_workflow_ref,
+          updated_at
+        FROM project_brief
+        WHERE id = 'current'
+      `)
+        .get();
+    if (row === undefined) {
+        return {
+            id: "current",
+            state: "missing",
+        };
+    }
+    const record = mapProjectBriefRow(row);
+    const state = currentSources !== undefined &&
+        !sourceDocsEqual(record.source_docs, projectBriefSourceFingerprints(currentSources))
+        ? "stale"
+        : "ready";
+    return {
+        id: "current",
+        state,
+        ...record,
+    };
+}
+export function upsertProjectBriefProjection(db, input) {
+    const updatedAt = nowIso(input.now);
+    const sourceDocs = projectBriefSourceFingerprints(input.source_docs);
+    db.prepare(`
+      INSERT INTO project_brief (
+        id,
+        product_summary,
+        tech_summary,
+        structure_summary,
+        principles_summary,
+        source_docs_json,
+        updated_by_activity_ref,
+        updated_by_workflow_ref,
+        updated_at
+      )
+      VALUES ('current', ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        product_summary = excluded.product_summary,
+        tech_summary = excluded.tech_summary,
+        structure_summary = excluded.structure_summary,
+        principles_summary = excluded.principles_summary,
+        source_docs_json = excluded.source_docs_json,
+        updated_by_activity_ref = excluded.updated_by_activity_ref,
+        updated_by_workflow_ref = excluded.updated_by_workflow_ref,
+        updated_at = excluded.updated_at
+    `).run(input.product_summary, input.tech_summary, input.structure_summary, input.principles_summary, stringifyJson(sourceDocs), input.updated_by_activity_ref ?? null, input.updated_by_workflow_ref ?? null, updatedAt);
+    return readProjectBriefProjection(db, input.source_docs);
+}
+//# sourceMappingURL=repository.js.map

package/dist/project-brief/source.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectBriefSourceDocument, ProjectBriefSourceDocumentFingerprint } from "./types.js";
+export declare function projectBriefSourceFingerprint(source: ProjectBriefSourceDocument): ProjectBriefSourceDocumentFingerprint;
+export declare function projectBriefSourceFingerprints(sources: ProjectBriefSourceDocument[]): ProjectBriefSourceDocumentFingerprint[];
+export declare function readProjectBriefSourceDocuments(options: {
+    workspaceRoot: string;
+    now?: () => Date;
+}): ProjectBriefSourceDocument[];
+//# sourceMappingURL=source.d.ts.map

package/dist/project-brief/source.js

@@ -0,0 +1,75 @@
+import { PROJECT_DOCS } from "../project-docs/context.js";
+import { WorkspaceOpsError, readViewerFile, } from "../workspace-ops/index.js";
+const PROJECT_BRIEF_SOURCE_MAX_BYTES = 24 * 1024;
+function unreadableReason(content) {
+    if (content.kind === "text") {
+        return undefined;
+    }
+    return content.reason;
+}
+export function projectBriefSourceFingerprint(source) {
+    const fingerprint = {
+        doc_key: source.doc_key,
+        path: source.path,
+        status: source.status,
+    };
+    if (source.size_bytes !== undefined) {
+        fingerprint.size_bytes = source.size_bytes;
+    }
+    if (source.blob_oid !== undefined) {
+        fingerprint.blob_oid = source.blob_oid;
+    }
+    if (source.unreadable_reason !== undefined) {
+        fingerprint.unreadable_reason = source.unreadable_reason;
+    }
+    if (source.content_truncated !== undefined) {
+        fingerprint.content_truncated = source.content_truncated;
+    }
+    return fingerprint;
+}
+export function projectBriefSourceFingerprints(sources) {
+    return sources.map(projectBriefSourceFingerprint);
+}
+export function readProjectBriefSourceDocuments(options) {
+    return PROJECT_DOCS.map((doc) => {
+        try {
+            const file = readViewerFile({
+                workspaceRoot: options.workspaceRoot,
+                path: doc.path,
+                maxBytes: PROJECT_BRIEF_SOURCE_MAX_BYTES,
+                ...(options.now === undefined ? {} : { now: options.now }),
+            });
+            if (file.content.kind !== "text") {
+                const unreadable = unreadableReason(file.content);
+                return {
+                    doc_key: doc.doc_key,
+                    path: doc.path,
+                    status: "unreadable",
+                    size_bytes: file.file.size_bytes,
+                    blob_oid: file.file.blob_oid,
+                    ...(unreadable === undefined ? {} : { unreadable_reason: unreadable }),
+                };
+            }
+            return {
+                doc_key: doc.doc_key,
+                path: doc.path,
+                status: "available",
+                size_bytes: file.file.size_bytes,
+                blob_oid: file.file.blob_oid,
+                content: file.content.text,
+                content_truncated: file.content.truncated,
+            };
+        }
+        catch (error) {
+            if (error instanceof WorkspaceOpsError && error.code === "not_found") {
+                return {
+                    doc_key: doc.doc_key,
+                    path: doc.path,
+                    status: "missing",
+                };
+            }
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=source.js.map

package/dist/project-brief/types.d.ts

@@ -0,0 +1,40 @@
+import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { ProjectDocKey } from "@tutti/shared/schemas/api";
+export type ProjectBriefSourceDocumentStatus = "available" | "missing" | "unreadable";
+export type ProjectBriefSourceDocument = {
+    doc_key: ProjectDocKey;
+    path: string;
+    status: ProjectBriefSourceDocumentStatus;
+    size_bytes?: number;
+    blob_oid?: string;
+    unreadable_reason?: string;
+    content?: string;
+    content_truncated?: boolean;
+};
+export type ProjectBriefSourceDocumentFingerprint = Omit<ProjectBriefSourceDocument, "content">;
+export type ProjectBriefSnapshot = {
+    product_summary: string;
+    tech_summary: string;
+    structure_summary: string;
+    principles_summary: string;
+};
+export type ProjectBriefRecord = ProjectBriefSnapshot & {
+    source_docs: ProjectBriefSourceDocumentFingerprint[];
+    updated_at: string;
+    updated_by_activity_ref?: ActivityRef;
+    updated_by_workflow_ref?: WorkflowInvocationRef;
+};
+export type ProjectBriefProjection = {
+    id: "current";
+    state: "missing";
+} | ({
+    id: "current";
+    state: "ready" | "stale";
+} & ProjectBriefRecord);
+export type UpsertProjectBriefInput = ProjectBriefSnapshot & {
+    source_docs: ProjectBriefSourceDocument[];
+    updated_by_activity_ref?: ActivityRef;
+    updated_by_workflow_ref?: WorkflowInvocationRef;
+    now?: () => Date;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/project-brief/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/project-docs/context.d.ts

@@ -0,0 +1,34 @@
+import type { ProjectDocKey, ProjectDocSummaryProjection } from "@tutti/shared/schemas/api";
+import { type ViewerFileResult } from "../workspace-ops/index.js";
+export declare const PROJECT_DOCS: ReadonlyArray<{
+    doc_key: ProjectDocKey;
+    path: string;
+}>;
+export declare function projectDocKeyForPath(path: string): ProjectDocKey | undefined;
+export declare function projectDocSummaryFromFile(docKey: ProjectDocKey, file: ViewerFileResult): ProjectDocSummaryProjection;
+export declare function readProjectDocsResponse(options: {
+    workspaceRoot: string;
+    now?: () => Date;
+}): {
+    snapshot: import("../workspace-ops/types.js").ViewerRepoSnapshot;
+    docs: {
+        size_bytes?: number;
+        blob_oid?: string;
+        unreadable_reason?: "binary" | "too_large" | "unsupported_encoding" | "restricted_path" | "secret_like";
+        last_commit?: {
+            title?: string;
+            oid: string;
+            short_oid: string;
+            committed_at: string;
+        };
+        status: "available" | "missing" | "unreadable";
+        path: string;
+        doc_key: "product" | "tech" | "structure" | "architecture_principles";
+    }[];
+};
+export declare function readProjectDocsSummaries(options: {
+    workspaceRoot: string;
+    now?: () => Date;
+}): ProjectDocSummaryProjection[];
+export declare function projectDocPath(docKey: ProjectDocKey): string;
+//# sourceMappingURL=context.d.ts.map

package/dist/project-docs/context.js

@@ -0,0 +1,86 @@
+import { WorkspaceOpsError, readViewerFile, readViewerSnapshot, } from "../workspace-ops/index.js";
+export const PROJECT_DOCS = [
+    { doc_key: "product", path: "product.md" },
+    { doc_key: "tech", path: "tech.md" },
+    { doc_key: "structure", path: "structure.md" },
+    { doc_key: "architecture_principles", path: "architecture-principles.md" },
+];
+export function projectDocKeyForPath(path) {
+    return PROJECT_DOCS.find((doc) => doc.path === path)?.doc_key;
+}
+function unreadableReasonForContent(content) {
+    if (content.kind === "text") {
+        return undefined;
+    }
+    return content.reason;
+}
+export function projectDocSummaryFromFile(docKey, file) {
+    if (file.content.kind === "text") {
+        return {
+            doc_key: docKey,
+            path: file.file.path,
+            status: "available",
+            size_bytes: file.file.size_bytes,
+            blob_oid: file.file.blob_oid,
+        };
+    }
+    const summary = {
+        doc_key: docKey,
+        path: file.file.path,
+        status: "unreadable",
+        size_bytes: file.file.size_bytes,
+        blob_oid: file.file.blob_oid,
+    };
+    const unreadableReason = unreadableReasonForContent(file.content);
+    if (unreadableReason !== undefined) {
+        summary.unreadable_reason = unreadableReason;
+    }
+    return summary;
+}
+function missingProjectDocSummary(docKey, path) {
+    return {
+        doc_key: docKey,
+        path,
+        status: "missing",
+    };
+}
+function readProjectDocSummary(options) {
+    try {
+        return projectDocSummaryFromFile(options.docKey, readViewerFile({
+            workspaceRoot: options.workspaceRoot,
+            path: options.path,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        }));
+    }
+    catch (error) {
+        if (error instanceof WorkspaceOpsError && error.code === "not_found") {
+            return missingProjectDocSummary(options.docKey, options.path);
+        }
+        throw error;
+    }
+}
+export function readProjectDocsResponse(options) {
+    return {
+        snapshot: readViewerSnapshot({
+            workspaceRoot: options.workspaceRoot,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        }),
+        docs: readProjectDocsSummaries(options),
+    };
+}
+export function readProjectDocsSummaries(options) {
+    return PROJECT_DOCS.map((doc) => readProjectDocSummary({
+        workspaceRoot: options.workspaceRoot,
+        docKey: doc.doc_key,
+        path: doc.path,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    }));
+}
+export function projectDocPath(docKey) {
+    const doc = PROJECT_DOCS.find((candidate) => candidate.doc_key === docKey);
+    if (doc === undefined) {
+        throw new WorkspaceOpsError("bad_request", "Project doc key is invalid");
+    }
+    return doc.path;
+}
+//# sourceMappingURL=context.js.map

package/dist/project-timeline/index.d.ts

@@ -0,0 +1,20 @@
+import { type ActivityRef, type EventRef, type TaskId, type WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { ProjectTimelineItem } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+export type ProjectTimelineEventKind = "context_sync" | "reference_summary" | "promotion_reconcile";
+export type ProjectTimelineEventInput = {
+    event_kind: ProjectTimelineEventKind;
+    status: NonNullable<ProjectTimelineItem["status"]>;
+    summary?: string;
+    activity_ref?: ActivityRef;
+    workflow_ref?: WorkflowInvocationRef;
+    task_id?: TaskId;
+    commit_oid?: string;
+    meta?: string[];
+    now?: () => Date;
+};
+export declare function recordProjectTimelineEvent(db: SqliteDatabase, input: ProjectTimelineEventInput): EventRef;
+export declare function readProjectTimelineEventItems(db: SqliteDatabase, options?: {
+    limit?: number;
+}): ProjectTimelineItem[];
+//# sourceMappingURL=index.d.ts.map

package/dist/project-timeline/index.js

@@ -0,0 +1,100 @@
+import { createEventRef, } from "@tutti/shared/ids";
+function parseMeta(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.filter((item) => typeof item === "string" && item.trim() !== "");
+    }
+    catch {
+        return [];
+    }
+}
+function titleForEvent(row) {
+    if (row.event_kind === "context_sync") {
+        return row.status === "failed" ? "Docs sync failed" : "Docs sync completed";
+    }
+    if (row.event_kind === "reference_summary") {
+        return row.status === "failed"
+            ? "Reference summary refresh failed"
+            : "Reference summaries refreshed";
+    }
+    return row.status === "failed" ? "Promotion reconcile failed" : "Promotion reconciled";
+}
+function kindForEvent(row) {
+    return row.event_kind === "promotion_reconcile" ? "promotion" : "procedure";
+}
+export function recordProjectTimelineEvent(db, input) {
+    const id = createEventRef();
+    const occurredAt = (input.now ?? (() => new Date()))().toISOString();
+    const meta = input.meta?.filter((item) => item.trim() !== "") ?? [];
+    db.prepare(`
+      INSERT INTO project_timeline_events (
+        id,
+        event_kind,
+        status,
+        summary,
+        activity_ref,
+        workflow_ref,
+        task_id,
+        commit_oid,
+        meta_json,
+        occurred_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, input.event_kind, input.status, input.summary ?? null, input.activity_ref ?? null, input.workflow_ref ?? null, input.task_id ?? null, input.commit_oid ?? null, JSON.stringify(meta), occurredAt);
+    return id;
+}
+export function readProjectTimelineEventItems(db, options = {}) {
+    const limit = Math.max(1, Math.min(200, Math.trunc(options.limit ?? 50)));
+    const rows = db
+        .prepare(`
+        SELECT
+          id,
+          event_kind,
+          status,
+          summary,
+          activity_ref,
+          workflow_ref,
+          task_id,
+          commit_oid,
+          meta_json,
+          occurred_at
+        FROM project_timeline_events
+        ORDER BY occurred_at DESC, id DESC
+        LIMIT ?
+      `)
+        .all(limit);
+    return rows.map((row) => {
+        const meta = parseMeta(row.meta_json);
+        const item = {
+            id: `event:${row.id}`,
+            kind: kindForEvent(row),
+            occurred_at: row.occurred_at,
+            title: titleForEvent(row),
+            status: row.status,
+        };
+        if (row.summary !== null && row.summary.trim() !== "") {
+            item.summary = row.summary;
+        }
+        if (row.activity_ref !== null) {
+            item.activity_ref = row.activity_ref;
+        }
+        if (row.workflow_ref !== null) {
+            item.workflow_ref = row.workflow_ref;
+        }
+        if (row.task_id !== null) {
+            item.task_id = row.task_id;
+        }
+        if (row.commit_oid !== null && row.commit_oid.trim() !== "") {
+            item.commit_oid = row.commit_oid;
+            item.commit_short_oid = row.commit_oid.slice(0, 12);
+        }
+        if (meta.length > 0) {
+            item.meta = meta;
+        }
+        return item;
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/prompt-templates/index.d.ts

@@ -0,0 +1,13 @@
+export type PromptTemplateKey = "procedures.project_context_bootstrap" | "procedures.context_sync" | "procedures.project_brief_refresh" | "procedures.scratchpad_refresh" | "procedures.task_compile" | "procedures.reference_file_summary" | "procedures.follow_up_check" | "runs.task_run" | "runs.task_continuation" | "runs.task_retry" | "chat.assistant" | "codex.no_write_smoke";
+export type RenderPromptTemplateOptions = {
+    templateKey: PromptTemplateKey;
+    variables?: Record<string, unknown>;
+    promptsRoot?: string;
+};
+export declare class PromptTemplateError extends Error {
+    readonly code: "template_not_found" | "template_path_invalid" | "missing_variable" | "unfilled_placeholder" | "secret_like_content";
+    constructor(code: "template_not_found" | "template_path_invalid" | "missing_variable" | "unfilled_placeholder" | "secret_like_content", message: string);
+}
+export declare function renderPromptTemplate(options: RenderPromptTemplateOptions): string;
+export declare function getPromptTemplatePath(templateKey: PromptTemplateKey, promptsRoot?: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/prompt-templates/index.js

@@ -0,0 +1,86 @@
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { REDACTION_FIXTURES, redactText, redactValue } from "@tutti/shared/utils/redaction";
+export class PromptTemplateError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "PromptTemplateError";
+    }
+}
+const defaultPromptsRoot = fileURLToPath(new URL("../../prompts", import.meta.url));
+const TEMPLATE_REGISTRY = {
+    "procedures.project_context_bootstrap": "procedures/project-context-bootstrap.md",
+    "procedures.context_sync": "procedures/context-sync.md",
+    "procedures.project_brief_refresh": "procedures/project-brief-refresh.md",
+    "procedures.scratchpad_refresh": "procedures/scratchpad-refresh.md",
+    "procedures.task_compile": "procedures/task-compile.md",
+    "procedures.reference_file_summary": "procedures/reference-file-summary.md",
+    "procedures.follow_up_check": "procedures/follow-up-check.md",
+    "runs.task_run": "runs/task-run.md",
+    "runs.task_continuation": "runs/task-continuation.md",
+    "runs.task_retry": "runs/task-retry.md",
+    "chat.assistant": "chat-assistant.md",
+    "codex.no_write_smoke": "codex/no-write-smoke.md",
+};
+const PLACEHOLDER_PATTERN = /\{\{([a-zA-Z0-9_]+)\}\}/gu;
+const LEADING_HTML_COMMENT_PATTERN = /^\s*(<!--[\s\S]*?-->)\s*/u;
+function templatePath(promptsRoot, templateKey) {
+    const root = resolve(promptsRoot);
+    const path = resolve(root, TEMPLATE_REGISTRY[templateKey]);
+    if (path !== root && !path.startsWith(`${root}/`)) {
+        throw new PromptTemplateError("template_path_invalid", `Template path escapes prompts root: ${templateKey}`);
+    }
+    return path;
+}
+function stringifyVariable(value) {
+    if (typeof value === "string") {
+        return redactText(value);
+    }
+    return JSON.stringify(redactValue(value), null, 2);
+}
+function stripLeadingTemplateMetadata(template) {
+    const match = LEADING_HTML_COMMENT_PATTERN.exec(template);
+    if (match === null || !match[1]?.includes("template_key:")) {
+        return template;
+    }
+    return template.slice(match[0].length);
+}
+function assertNoSecretLikeContent(rendered) {
+    if (redactText(rendered) !== rendered) {
+        throw new PromptTemplateError("secret_like_content", "Rendered prompt contains secret-like content");
+    }
+    for (const fixture of REDACTION_FIXTURES) {
+        if (rendered.includes(fixture)) {
+            throw new PromptTemplateError("secret_like_content", "Rendered prompt contains a redaction fixture value");
+        }
+    }
+}
+export function renderPromptTemplate(options) {
+    const promptsRoot = options.promptsRoot ?? defaultPromptsRoot;
+    const variables = options.variables ?? {};
+    const path = templatePath(promptsRoot, options.templateKey);
+    let template;
+    try {
+        template = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        throw new PromptTemplateError("template_not_found", error instanceof Error
+            ? `Template not found for ${options.templateKey}: ${error.message}`
+            : `Template not found for ${options.templateKey}`);
+    }
+    const rendered = stripLeadingTemplateMetadata(template).replace(PLACEHOLDER_PATTERN, (placeholder, name) => {
+        if (!Object.hasOwn(variables, name)) {
+            throw new PromptTemplateError("missing_variable", `Missing prompt template variable: ${name}`);
+        }
+        return stringifyVariable(variables[name]);
+    });
+    assertNoSecretLikeContent(rendered);
+    return rendered;
+}
+export function getPromptTemplatePath(templateKey, promptsRoot = defaultPromptsRoot) {
+    return join(resolve(promptsRoot), TEMPLATE_REGISTRY[templateKey]);
+}
+//# sourceMappingURL=index.js.map

package/dist/provider-usage/index.d.ts

@@ -0,0 +1,37 @@
+import type { ProviderUsageBreakdownProjection, ProviderUsageModelSummaryProjection, ProviderUsageProjection, ProviderUsageSourceSummaryProjection } from "@tutti/shared/schemas/api";
+import type { ActivityRef, RunResultId, TaskId, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { RunLineage } from "@tutti/shared/domain";
+import type { OpenAiTokenUsage } from "../providers/openai/token-usage.js";
+import type { SqliteDatabase } from "../store/index.js";
+export type ProviderUsageEventInput = {
+    provider: "openai";
+    source: string;
+    model?: string;
+    usage: OpenAiTokenUsage;
+    activity_ref?: ActivityRef;
+    workflow_ref?: WorkflowInvocationRef;
+    task_id?: TaskId;
+    run_result_id?: RunResultId;
+    run_lineage_kind?: RunLineage["kind"];
+    now?: () => Date;
+};
+export type ProviderUsageRecorder = (input: ProviderUsageEventInput) => void;
+export type ProviderUsageAnchorLookup = {
+    activity_ref?: ActivityRef;
+    workflow_ref?: WorkflowInvocationRef;
+    task_id?: TaskId;
+    run_result_id?: RunResultId;
+};
+type ProviderUsageAnchorQueryOptions = {
+    sources?: readonly string[];
+};
+export declare function providerUsageSourceMetadata(source: string): Pick<ProviderUsageSourceSummaryProjection, "label" | "category">;
+export declare function recordProviderUsageEvent(db: SqliteDatabase, input: ProviderUsageEventInput): void;
+export declare function readProviderUsageBreakdownForAnchors(db: SqliteDatabase, anchors: ProviderUsageAnchorLookup, options?: ProviderUsageAnchorQueryOptions): ProviderUsageBreakdownProjection;
+export declare function readProviderUsageSourceSummariesForAnchors(db: SqliteDatabase, anchors: ProviderUsageAnchorLookup, options?: ProviderUsageAnchorQueryOptions): ProviderUsageSourceSummaryProjection[];
+export declare function readProviderUsageModelSummariesForAnchors(db: SqliteDatabase, anchors: ProviderUsageAnchorLookup, options?: ProviderUsageAnchorQueryOptions): ProviderUsageModelSummaryProjection[];
+export declare function readProviderUsageProjection(db: SqliteDatabase, options?: {
+    now?: () => Date;
+}): ProviderUsageProjection;
+export {};
+//# sourceMappingURL=index.d.ts.map