@stevenvincentone/intidev-agentloops 0.1.0

package/dist/convergence.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MIN_SOURCES = exports.SOURCE_CONVERGENCE_SCHEMA_VERSION = void 0;
+exports.sourceConvergenceReport = sourceConvergenceReport;
+exports.SOURCE_CONVERGENCE_SCHEMA_VERSION = 1;
+exports.DEFAULT_MIN_SOURCES = 2;
+/**
+ * Source-convergence audit (ported concept from Inti's ledger): surface the
+ * Patterns whose member tickets were reported through **multiple distinct
+ * sources**. A pattern corroborated by, say, a smoke run + a user report + an
+ * agent is far higher-signal than a single-source cluster.
+ *
+ * Pure and deterministic apart from `generatedAt`. Patterns are returned sorted
+ * by source diversity (then ticket count, then id) so output is stable.
+ */
+function sourceConvergenceReport(tickets, patterns, options = {}) {
+    const minSources = Math.max(1, Math.trunc(options.minSources ?? exports.DEFAULT_MIN_SOURCES));
+    const familyFilter = options.family;
+    const byId = new Map(tickets.map((ticket) => [ticket.id, ticket]));
+    const scoped = patterns.filter((pattern) => !familyFilter || pattern.family === familyFilter);
+    const analyzed = scoped.map((pattern) => {
+        const members = pattern.ticketIds
+            .map((id) => byId.get(id))
+            .filter((ticket) => Boolean(ticket));
+        const sources = {};
+        for (const ticket of members) {
+            sources[ticket.source] = (sources[ticket.source] ?? 0) + 1;
+        }
+        const sourceCount = Object.keys(sources).length;
+        return {
+            id: pattern.id,
+            family: pattern.family,
+            title: pattern.title,
+            status: pattern.status,
+            ticketCount: members.length,
+            sourceCount,
+            sources,
+            converged: sourceCount >= minSources,
+            tickets: members.map((ticket) => ({
+                id: ticket.id,
+                alias: ticket.aliases[0] ?? ticket.id,
+                source: ticket.source,
+                kind: ticket.kind,
+                status: ticket.status,
+            })),
+        };
+    });
+    const converged = analyzed.filter((pattern) => pattern.converged);
+    const visible = (options.includeAll ? analyzed : converged).sort((a, b) => b.sourceCount - a.sourceCount ||
+        b.ticketCount - a.ticketCount ||
+        a.id.localeCompare(b.id));
+    return {
+        schemaVersion: exports.SOURCE_CONVERGENCE_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        filters: { family: familyFilter ?? null, minSources },
+        summary: {
+            totalPatterns: analyzed.length,
+            convergedPatterns: converged.length,
+            maxSourceConvergence: analyzed.reduce((max, pattern) => Math.max(max, pattern.sourceCount), 0),
+        },
+        patterns: visible,
+    };
+}
+//# sourceMappingURL=convergence.js.map

package/dist/dashboard.d.ts

@@ -0,0 +1,23 @@
+import { AgentLoopStore } from "./store";
+import { Pattern, Ticket } from "./types";
+import { SourceConvergenceReport } from "./convergence";
+import { GuardGapReport } from "./guards";
+export interface DashboardData {
+    project: string;
+    generatedAt: string;
+    summary: Awaited<ReturnType<AgentLoopStore["summary"]>>;
+    tickets: Ticket[];
+    patterns: Pattern[];
+    convergence: SourceConvergenceReport;
+    guardGaps: GuardGapReport;
+}
+/** Gather everything the dashboard renders from a store (filesystem or Postgres). */
+export declare function gatherDashboardData(store: AgentLoopStore): Promise<DashboardData>;
+export declare function escapeHtml(value: string): string;
+/**
+ * Render a complete, dependency-free HTML dashboard for the ledger. All dynamic
+ * text is HTML-escaped. The output is a single self-contained document (inline
+ * CSS + a few lines of tab-switching JS), so it opens directly in a browser or
+ * is served as-is.
+ */
+export declare function renderDashboard(data: DashboardData): string;

package/dist/dashboard.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherDashboardData = gatherDashboardData;
+exports.escapeHtml = escapeHtml;
+exports.renderDashboard = renderDashboard;
+/** Gather everything the dashboard renders from a store (filesystem or Postgres). */
+async function gatherDashboardData(store) {
+    const summary = await store.summary();
+    return {
+        project: summary.project,
+        generatedAt: new Date().toISOString(),
+        summary,
+        tickets: await store.listTickets({ status: "all" }),
+        patterns: await store.listPatterns({ status: "all" }),
+        convergence: await store.sourceConvergence({ includeAll: true }),
+        guardGaps: await store.guardGaps({}),
+    };
+}
+const ESCAPES = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
+function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (char) => ESCAPES[char]);
+}
+const QUEUE_LABELS = {
+    ISSUE: "Issues",
+    USER: "User",
+    DEV: "Development",
+};
+const QUEUE_ORDER = ["ISSUE", "USER", "DEV"];
+function prefixOf(ticket) {
+    const alias = ticket.aliases[0] ?? ticket.id;
+    return alias.split("-")[0];
+}
+function card(label, value) {
+    return `<div class="card"><div class="num">${escapeHtml(String(value))}</div><div class="lbl">${escapeHtml(label)}</div></div>`;
+}
+function statusBadge(status) {
+    return `<span class="badge s-${escapeHtml(status)}">${escapeHtml(status)}</span>`;
+}
+function ticketTable(tickets) {
+    if (tickets.length === 0)
+        return `<p class="empty">No tickets.</p>`;
+    const rows = tickets
+        .map((t) => `<tr>
+        <td class="mono">${escapeHtml(t.aliases[0] ?? t.id)}</td>
+        <td>${escapeHtml(t.kind)}</td>
+        <td>${statusBadge(t.status)}</td>
+        <td>${escapeHtml(t.family)}</td>
+        <td>${escapeHtml(t.source)}</td>
+        <td>${escapeHtml(t.title || "(untitled)")}</td>
+      </tr>`)
+        .join("\n");
+    return `<table>
+    <thead><tr><th>Alias</th><th>Kind</th><th>Status</th><th>Family</th><th>Source</th><th>Title</th></tr></thead>
+    <tbody>${rows}</tbody>
+  </table>`;
+}
+function ticketsTab(tickets) {
+    const groups = new Map();
+    for (const ticket of tickets) {
+        const prefix = prefixOf(ticket);
+        const list = groups.get(prefix) ?? [];
+        list.push(ticket);
+        groups.set(prefix, list);
+    }
+    const orderedPrefixes = [
+        ...QUEUE_ORDER.filter((p) => groups.has(p)),
+        ...[...groups.keys()].filter((p) => !QUEUE_ORDER.includes(p)).sort(),
+    ];
+    if (orderedPrefixes.length === 0)
+        return `<p class="empty">No tickets yet.</p>`;
+    return orderedPrefixes
+        .map((prefix) => {
+        const list = groups.get(prefix) ?? [];
+        const label = QUEUE_LABELS[prefix] ?? prefix;
+        return `<h3>${escapeHtml(label)} <span class="count">${list.length}</span></h3>${ticketTable(list)}`;
+    })
+        .join("\n");
+}
+function patternsTab(patterns) {
+    if (patterns.length === 0)
+        return `<p class="empty">No patterns yet.</p>`;
+    const rows = patterns
+        .map((p) => `<tr>
+        <td class="mono">${escapeHtml(p.id)}</td>
+        <td>${escapeHtml(p.family)}</td>
+        <td>${statusBadge(p.status)}</td>
+        <td>${p.ticketIds.length}</td>
+        <td>${escapeHtml(p.title)}</td>
+      </tr>`)
+        .join("\n");
+    return `<table>
+    <thead><tr><th>Pattern</th><th>Family</th><th>Status</th><th>Tickets</th><th>Title</th></tr></thead>
+    <tbody>${rows}</tbody>
+  </table>`;
+}
+function convergenceTab(report) {
+    const head = `<p class="note">${report.summary.convergedPatterns} of ${report.summary.totalPatterns} patterns span multiple sources (max ${report.summary.maxSourceConvergence}).</p>`;
+    if (report.patterns.length === 0)
+        return `${head}<p class="empty">No patterns.</p>`;
+    const rows = report.patterns
+        .map((p) => {
+        const sources = Object.entries(p.sources)
+            .map(([s, n]) => `${escapeHtml(s)}×${n}`)
+            .join(", ");
+        return `<tr>
+        <td class="mono">${escapeHtml(p.id)}</td>
+        <td>${escapeHtml(p.family)}</td>
+        <td>${p.sourceCount}</td>
+        <td>${p.ticketCount}</td>
+        <td>${p.converged ? "✓" : ""}</td>
+        <td>${sources}</td>
+      </tr>`;
+    })
+        .join("\n");
+    return `${head}<table>
+    <thead><tr><th>Pattern</th><th>Family</th><th>Sources</th><th>Tickets</th><th>Converged</th><th>Breakdown</th></tr></thead>
+    <tbody>${rows}</tbody>
+  </table>`;
+}
+function guardGapsTab(report) {
+    const head = `<p class="note">${report.summary.gaps} gap(s): ${report.summary.missing} missing, ${report.summary.deferred} deferred (of ${report.summary.resolvedConsidered} resolved considered).</p>`;
+    if (report.gaps.length === 0)
+        return `${head}<p class="empty">No guard gaps. 🎉</p>`;
+    const rows = report.gaps
+        .map((g) => `<tr>
+        <td class="mono">${escapeHtml(g.alias)}</td>
+        <td>${escapeHtml(g.kind)}</td>
+        <td><span class="badge gap-${escapeHtml(g.reason)}">${escapeHtml(g.reason)}</span></td>
+        <td>${escapeHtml(g.family)}</td>
+      </tr>`)
+        .join("\n");
+    return `${head}<table>
+    <thead><tr><th>Ticket</th><th>Kind</th><th>Gap</th><th>Family</th></tr></thead>
+    <tbody>${rows}</tbody>
+  </table>`;
+}
+const STYLE = `
+  :root { --bg:#0f1117; --panel:#171a21; --line:#272b35; --txt:#e6e8ee; --muted:#9aa3b2; --accent:#6ea8fe; }
+  * { box-sizing: border-box; }
+  body { margin:0; font:14px/1.5 system-ui,-apple-system,Segoe UI,Roboto,sans-serif; background:var(--bg); color:var(--txt); }
+  header { padding:24px 28px 8px; }
+  h1 { margin:0; font-size:20px; }
+  .meta { color:var(--muted); margin:4px 0 0; }
+  .cards { display:flex; flex-wrap:wrap; gap:12px; padding:16px 28px; }
+  .card { background:var(--panel); border:1px solid var(--line); border-radius:10px; padding:12px 16px; min-width:110px; }
+  .card .num { font-size:22px; font-weight:600; }
+  .card .lbl { color:var(--muted); font-size:12px; }
+  nav { display:flex; gap:4px; padding:0 28px; border-bottom:1px solid var(--line); flex-wrap:wrap; }
+  nav button { background:none; border:none; color:var(--muted); padding:10px 14px; cursor:pointer; font-size:14px; border-bottom:2px solid transparent; }
+  nav button.active { color:var(--txt); border-bottom-color:var(--accent); }
+  main { padding:18px 28px 60px; }
+  .tab { display:none; }
+  h3 { margin:18px 0 8px; font-size:15px; }
+  h3 .count { color:var(--muted); font-weight:400; }
+  table { width:100%; border-collapse:collapse; margin-bottom:8px; }
+  th, td { text-align:left; padding:7px 10px; border-bottom:1px solid var(--line); vertical-align:top; }
+  th { color:var(--muted); font-weight:500; font-size:12px; text-transform:uppercase; letter-spacing:.03em; }
+  .mono { font-family:ui-monospace,SFMono-Regular,Menlo,monospace; color:var(--accent); white-space:nowrap; }
+  .badge { font-size:12px; padding:1px 8px; border-radius:999px; background:#2a2f3a; }
+  .s-resolved { background:#163a2b; color:#7ee2a8; }
+  .s-active { background:#16314a; color:#7fb6ff; }
+  .s-reopened { background:#4a2516; color:#ffb27f; }
+  .s-deferred { background:#33363f; color:#c9ced8; }
+  .gap-missing { background:#4a1616; color:#ff8f8f; }
+  .gap-deferred { background:#4a3b16; color:#ffd98f; }
+  .empty, .note { color:var(--muted); }
+  footer { color:var(--muted); padding:0 28px 28px; font-size:12px; }
+`;
+/**
+ * Render a complete, dependency-free HTML dashboard for the ledger. All dynamic
+ * text is HTML-escaped. The output is a single self-contained document (inline
+ * CSS + a few lines of tab-switching JS), so it opens directly in a browser or
+ * is served as-is.
+ */
+function renderDashboard(data) {
+    const s = data.summary;
+    const cards = [
+        card("Tickets", s.totalTickets),
+        card("Triaged", s.triagedTickets),
+        card("Active", s.activeTickets),
+        card("Resolved", s.resolvedTickets),
+        card("Patterns", data.patterns.length),
+        card("Converged", data.convergence.summary.convergedPatterns),
+        card("Guard gaps", data.guardGaps.summary.gaps),
+    ].join("");
+    const tabs = [
+        { id: "tickets", label: "Tickets", body: ticketsTab(data.tickets) },
+        { id: "patterns", label: "Patterns", body: patternsTab(data.patterns) },
+        { id: "convergence", label: "Convergence", body: convergenceTab(data.convergence) },
+        { id: "guards", label: "Guard Gaps", body: guardGapsTab(data.guardGaps) },
+    ];
+    const nav = tabs
+        .map((t, i) => `<button class="${i === 0 ? "active" : ""}" onclick="showTab('${t.id}', this)">${escapeHtml(t.label)}</button>`)
+        .join("");
+    const sections = tabs
+        .map((t, i) => `<section id="${t.id}" class="tab" style="display:${i === 0 ? "block" : "none"}">${t.body}</section>`)
+        .join("\n");
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${escapeHtml(data.project)} — AgentLoops</title>
+<style>${STYLE}</style>
+</head>
+<body>
+<header>
+  <h1>${escapeHtml(data.project)}</h1>
+  <p class="meta">AgentLoops dashboard · generated ${escapeHtml(data.generatedAt)}</p>
+</header>
+<div class="cards">${cards}</div>
+<nav>${nav}</nav>
+<main>
+${sections}
+</main>
+<footer>Read-only snapshot. Manage tickets with the <code>agentloop</code> CLI or MCP server.</footer>
+<script>
+function showTab(id, btn) {
+  document.querySelectorAll('.tab').forEach(function (t) { t.style.display = 'none'; });
+  document.getElementById(id).style.display = 'block';
+  document.querySelectorAll('nav button').forEach(function (b) { b.classList.remove('active'); });
+  btn.classList.add('active');
+}
+</script>
+</body>
+</html>`;
+}
+//# sourceMappingURL=dashboard.js.map

package/dist/guards.d.ts

@@ -0,0 +1,53 @@
+import { ProjectConfig, Ticket } from "./types";
+export declare const GUARD_GAP_SCHEMA_VERSION: 1;
+/** Queue prefixes that are expected to carry a regression guard once resolved. */
+export declare const DEFAULT_GUARD_QUEUES: string[];
+export type GuardGapReason = "missing" | "deferred" | "waived";
+export interface GuardGapOptions {
+    /** Restrict to a single family. */
+    family?: string;
+    /** Treat intentionally waived guards as gaps too. Default false. */
+    includeWaived?: boolean;
+    /** Consider every resolved ticket, not just guard-relevant queues. Default false. */
+    allKinds?: boolean;
+    /** Queue prefixes that expect a guard. Default ISSUE, USER. */
+    guardQueues?: string[];
+}
+export interface GuardGap {
+    id: string;
+    alias: string;
+    kind: string;
+    source: string;
+    family: string;
+    guardStatus: string;
+    reason: GuardGapReason;
+    resolutionSummary?: string;
+}
+export interface GuardGapReport {
+    schemaVersion: typeof GUARD_GAP_SCHEMA_VERSION;
+    generatedAt: string;
+    filters: {
+        family: string | null;
+        includeWaived: boolean;
+        allKinds: boolean;
+    };
+    summary: {
+        /** Resolved tickets considered (after queue/family scoping). */
+        resolvedConsidered: number;
+        guarded: number;
+        gaps: number;
+        missing: number;
+        deferred: number;
+        waived: number;
+    };
+    gaps: GuardGap[];
+}
+/**
+ * Guard-gap report (ported concept from Inti's guard audit): resolved tickets
+ * that should carry a regression guard but do not. By default only tickets in
+ * guard-relevant queues (ISSUE, USER — defects and user reports) are considered;
+ * `allKinds` widens it to every resolved ticket.
+ *
+ * Pure and deterministic apart from `generatedAt`.
+ */
+export declare function guardGapReport(tickets: Ticket[], config: ProjectConfig, options?: GuardGapOptions): GuardGapReport;

package/dist/guards.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GUARD_QUEUES = exports.GUARD_GAP_SCHEMA_VERSION = void 0;
+exports.guardGapReport = guardGapReport;
+const aliases_1 = require("./aliases");
+exports.GUARD_GAP_SCHEMA_VERSION = 1;
+/** Guard statuses that count as an active regression guard. */
+const ACTIVE_GUARD = new Set(["guard_added", "guard_existing"]);
+/** Queue prefixes that are expected to carry a regression guard once resolved. */
+exports.DEFAULT_GUARD_QUEUES = ["ISSUE", "USER"];
+const REASON_ORDER = { missing: 0, deferred: 1, waived: 2 };
+/**
+ * Guard-gap report (ported concept from Inti's guard audit): resolved tickets
+ * that should carry a regression guard but do not. By default only tickets in
+ * guard-relevant queues (ISSUE, USER — defects and user reports) are considered;
+ * `allKinds` widens it to every resolved ticket.
+ *
+ * Pure and deterministic apart from `generatedAt`.
+ */
+function guardGapReport(tickets, config, options = {}) {
+    const family = options.family;
+    const includeWaived = options.includeWaived ?? false;
+    const allKinds = options.allKinds ?? false;
+    const guardQueues = new Set((options.guardQueues ?? exports.DEFAULT_GUARD_QUEUES).map((prefix) => prefix.toUpperCase()));
+    const relevant = tickets.filter((ticket) => {
+        if (ticket.status !== "resolved")
+            return false;
+        if (family && ticket.family !== family)
+            return false;
+        if (allKinds)
+            return true;
+        return guardQueues.has((0, aliases_1.resolveQueuePrefix)({ kind: ticket.kind, source: ticket.source }, config));
+    });
+    let guarded = 0;
+    let missing = 0;
+    let deferred = 0;
+    let waived = 0;
+    const gaps = [];
+    for (const ticket of relevant) {
+        const guardStatus = ticket.guardStatus ?? "none";
+        if (ACTIVE_GUARD.has(guardStatus)) {
+            guarded += 1;
+            continue;
+        }
+        let reason;
+        if (guardStatus === "guard_deferred") {
+            reason = "deferred";
+            deferred += 1;
+        }
+        else if (guardStatus === "guard_waived") {
+            reason = "waived";
+            waived += 1;
+            if (!includeWaived)
+                continue;
+        }
+        else {
+            reason = "missing";
+            missing += 1;
+        }
+        gaps.push({
+            id: ticket.id,
+            alias: ticket.aliases[0] ?? ticket.id,
+            kind: ticket.kind,
+            source: ticket.source,
+            family: ticket.family,
+            guardStatus,
+            reason,
+            resolutionSummary: ticket.resolutionSummary,
+        });
+    }
+    gaps.sort((a, b) => REASON_ORDER[a.reason] - REASON_ORDER[b.reason] || a.id.localeCompare(b.id));
+    return {
+        schemaVersion: exports.GUARD_GAP_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        filters: { family: family ?? null, includeWaived, allKinds },
+        summary: {
+            resolvedConsidered: relevant.length,
+            guarded,
+            gaps: gaps.length,
+            missing,
+            deferred,
+            waived,
+        },
+        gaps,
+    };
+}
+//# sourceMappingURL=guards.js.map

package/dist/handoff.d.ts

@@ -0,0 +1,10 @@
+import { Ticket } from "./types";
+/**
+ * Build the copyable agent handoff prompt for a ticket.
+ *
+ * Pure and deterministic: if the ticket carries an explicit `handoffText`,
+ * that is used verbatim; otherwise a structured default is derived from the
+ * ticket fields. Shared by the CLI `handoff` command and the MCP
+ * `agentloop_handoff` tool so both stay in sync.
+ */
+export declare function buildHandoffPrompt(ticket: Ticket): string;

package/dist/handoff.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHandoffPrompt = buildHandoffPrompt;
+/**
+ * Build the copyable agent handoff prompt for a ticket.
+ *
+ * Pure and deterministic: if the ticket carries an explicit `handoffText`,
+ * that is used verbatim; otherwise a structured default is derived from the
+ * ticket fields. Shared by the CLI `handoff` command and the MCP
+ * `agentloop_handoff` tool so both stay in sync.
+ */
+function buildHandoffPrompt(ticket) {
+    if (ticket.handoffText) {
+        return ticket.handoffText;
+    }
+    return [
+        `Fix ${ticket.kind} ${ticket.id}: ${ticket.title}`,
+        `Symptom: ${ticket.summary}`,
+        `Family: ${ticket.family}`,
+        `Severity: ${ticket.severity}`,
+    ].join("\n");
+}
+//# sourceMappingURL=handoff.js.map

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export { AgentLoopStore } from "./store";
+export * from "./types";
+export * from "./config";
+export { FilesystemStateBackend, MemoryStateBackend, } from "./backend";
+export type { StateBackend } from "./backend";
+export { PostgresStateBackend, TICKET_SCHEMA_SQL, serializeState, deserializeRows, } from "./postgres";
+export type { PgClient, RelationalRows } from "./postgres";
+export { resolveBackend, resolvePostgresUrl } from "./storage";
+export type { BackendSelection, ResolveBackendOptions } from "./storage";
+export { renderDashboard, gatherDashboardData, escapeHtml } from "./dashboard";
+export type { DashboardData } from "./dashboard";
+export { createDashboardServer } from "./serve";
+export { buildHandoffPrompt } from "./handoff";
+export { noopRedactor, createPatternRedactor, resolveRedactor } from "./redaction";
+export { deriveAliases, resolveQueuePrefix, canonicalKey, padSeq } from "./aliases";
+export { sourceConvergenceReport, SOURCE_CONVERGENCE_SCHEMA_VERSION, DEFAULT_MIN_SOURCES, } from "./convergence";
+export type { SourceConvergenceOptions, SourceConvergenceReport, ConvergencePattern, ConvergenceTicketRef, } from "./convergence";
+export { guardGapReport, GUARD_GAP_SCHEMA_VERSION, DEFAULT_GUARD_QUEUES } from "./guards";
+export type { GuardGapOptions, GuardGapReport, GuardGap, GuardGapReason, } from "./guards";
+export { resolutionKnowledge, knowledgeGaps, KNOWLEDGE_SCHEMA_VERSION } from "./knowledge";
+export type { KnowledgeEntry, KnowledgeSearchOptions, ResolutionKnowledgeReport, KnowledgeGap, KnowledgeGapReason, KnowledgeGapsOptions, KnowledgeGapsReport, } from "./knowledge";
+export { relatedTickets, PRIOR_ART_SCHEMA_VERSION, DEFAULT_PRIOR_ART_WEIGHTS, } from "./prior-art";
+export type { PriorArtWeights, PriorArtOptions, PriorArtReport, RelatedTicket, } from "./prior-art";
+export { createMcpServer, startStdioMcpServer, summaryTool, listTool, showTool, handoffTool, createTicketTool, noteTool, workflowTool, resolveTool, guardTool, MCP_SCHEMA_VERSION, MCP_SERVER_NAME, } from "./mcp";
+export type { CreateMcpServerOptions, WriteAction, WriteResult } from "./mcp";

package/dist/index.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_SERVER_NAME = exports.MCP_SCHEMA_VERSION = exports.guardTool = exports.resolveTool = exports.workflowTool = exports.noteTool = exports.createTicketTool = exports.handoffTool = exports.showTool = exports.listTool = exports.summaryTool = exports.startStdioMcpServer = exports.createMcpServer = exports.DEFAULT_PRIOR_ART_WEIGHTS = exports.PRIOR_ART_SCHEMA_VERSION = exports.relatedTickets = exports.KNOWLEDGE_SCHEMA_VERSION = exports.knowledgeGaps = exports.resolutionKnowledge = exports.DEFAULT_GUARD_QUEUES = exports.GUARD_GAP_SCHEMA_VERSION = exports.guardGapReport = exports.DEFAULT_MIN_SOURCES = exports.SOURCE_CONVERGENCE_SCHEMA_VERSION = exports.sourceConvergenceReport = exports.padSeq = exports.canonicalKey = exports.resolveQueuePrefix = exports.deriveAliases = exports.resolveRedactor = exports.createPatternRedactor = exports.noopRedactor = exports.buildHandoffPrompt = exports.createDashboardServer = exports.escapeHtml = exports.gatherDashboardData = exports.renderDashboard = exports.resolvePostgresUrl = exports.resolveBackend = exports.deserializeRows = exports.serializeState = exports.TICKET_SCHEMA_SQL = exports.PostgresStateBackend = exports.MemoryStateBackend = exports.FilesystemStateBackend = exports.AgentLoopStore = void 0;
+var store_1 = require("./store");
+Object.defineProperty(exports, "AgentLoopStore", { enumerable: true, get: function () { return store_1.AgentLoopStore; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./config"), exports);
+var backend_1 = require("./backend");
+Object.defineProperty(exports, "FilesystemStateBackend", { enumerable: true, get: function () { return backend_1.FilesystemStateBackend; } });
+Object.defineProperty(exports, "MemoryStateBackend", { enumerable: true, get: function () { return backend_1.MemoryStateBackend; } });
+var postgres_1 = require("./postgres");
+Object.defineProperty(exports, "PostgresStateBackend", { enumerable: true, get: function () { return postgres_1.PostgresStateBackend; } });
+Object.defineProperty(exports, "TICKET_SCHEMA_SQL", { enumerable: true, get: function () { return postgres_1.TICKET_SCHEMA_SQL; } });
+Object.defineProperty(exports, "serializeState", { enumerable: true, get: function () { return postgres_1.serializeState; } });
+Object.defineProperty(exports, "deserializeRows", { enumerable: true, get: function () { return postgres_1.deserializeRows; } });
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "resolveBackend", { enumerable: true, get: function () { return storage_1.resolveBackend; } });
+Object.defineProperty(exports, "resolvePostgresUrl", { enumerable: true, get: function () { return storage_1.resolvePostgresUrl; } });
+var dashboard_1 = require("./dashboard");
+Object.defineProperty(exports, "renderDashboard", { enumerable: true, get: function () { return dashboard_1.renderDashboard; } });
+Object.defineProperty(exports, "gatherDashboardData", { enumerable: true, get: function () { return dashboard_1.gatherDashboardData; } });
+Object.defineProperty(exports, "escapeHtml", { enumerable: true, get: function () { return dashboard_1.escapeHtml; } });
+var serve_1 = require("./serve");
+Object.defineProperty(exports, "createDashboardServer", { enumerable: true, get: function () { return serve_1.createDashboardServer; } });
+var handoff_1 = require("./handoff");
+Object.defineProperty(exports, "buildHandoffPrompt", { enumerable: true, get: function () { return handoff_1.buildHandoffPrompt; } });
+var redaction_1 = require("./redaction");
+Object.defineProperty(exports, "noopRedactor", { enumerable: true, get: function () { return redaction_1.noopRedactor; } });
+Object.defineProperty(exports, "createPatternRedactor", { enumerable: true, get: function () { return redaction_1.createPatternRedactor; } });
+Object.defineProperty(exports, "resolveRedactor", { enumerable: true, get: function () { return redaction_1.resolveRedactor; } });
+var aliases_1 = require("./aliases");
+Object.defineProperty(exports, "deriveAliases", { enumerable: true, get: function () { return aliases_1.deriveAliases; } });
+Object.defineProperty(exports, "resolveQueuePrefix", { enumerable: true, get: function () { return aliases_1.resolveQueuePrefix; } });
+Object.defineProperty(exports, "canonicalKey", { enumerable: true, get: function () { return aliases_1.canonicalKey; } });
+Object.defineProperty(exports, "padSeq", { enumerable: true, get: function () { return aliases_1.padSeq; } });
+var convergence_1 = require("./convergence");
+Object.defineProperty(exports, "sourceConvergenceReport", { enumerable: true, get: function () { return convergence_1.sourceConvergenceReport; } });
+Object.defineProperty(exports, "SOURCE_CONVERGENCE_SCHEMA_VERSION", { enumerable: true, get: function () { return convergence_1.SOURCE_CONVERGENCE_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "DEFAULT_MIN_SOURCES", { enumerable: true, get: function () { return convergence_1.DEFAULT_MIN_SOURCES; } });
+var guards_1 = require("./guards");
+Object.defineProperty(exports, "guardGapReport", { enumerable: true, get: function () { return guards_1.guardGapReport; } });
+Object.defineProperty(exports, "GUARD_GAP_SCHEMA_VERSION", { enumerable: true, get: function () { return guards_1.GUARD_GAP_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "DEFAULT_GUARD_QUEUES", { enumerable: true, get: function () { return guards_1.DEFAULT_GUARD_QUEUES; } });
+var knowledge_1 = require("./knowledge");
+Object.defineProperty(exports, "resolutionKnowledge", { enumerable: true, get: function () { return knowledge_1.resolutionKnowledge; } });
+Object.defineProperty(exports, "knowledgeGaps", { enumerable: true, get: function () { return knowledge_1.knowledgeGaps; } });
+Object.defineProperty(exports, "KNOWLEDGE_SCHEMA_VERSION", { enumerable: true, get: function () { return knowledge_1.KNOWLEDGE_SCHEMA_VERSION; } });
+var prior_art_1 = require("./prior-art");
+Object.defineProperty(exports, "relatedTickets", { enumerable: true, get: function () { return prior_art_1.relatedTickets; } });
+Object.defineProperty(exports, "PRIOR_ART_SCHEMA_VERSION", { enumerable: true, get: function () { return prior_art_1.PRIOR_ART_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "DEFAULT_PRIOR_ART_WEIGHTS", { enumerable: true, get: function () { return prior_art_1.DEFAULT_PRIOR_ART_WEIGHTS; } });
+var mcp_1 = require("./mcp");
+Object.defineProperty(exports, "createMcpServer", { enumerable: true, get: function () { return mcp_1.createMcpServer; } });
+Object.defineProperty(exports, "startStdioMcpServer", { enumerable: true, get: function () { return mcp_1.startStdioMcpServer; } });
+Object.defineProperty(exports, "summaryTool", { enumerable: true, get: function () { return mcp_1.summaryTool; } });
+Object.defineProperty(exports, "listTool", { enumerable: true, get: function () { return mcp_1.listTool; } });
+Object.defineProperty(exports, "showTool", { enumerable: true, get: function () { return mcp_1.showTool; } });
+Object.defineProperty(exports, "handoffTool", { enumerable: true, get: function () { return mcp_1.handoffTool; } });
+Object.defineProperty(exports, "createTicketTool", { enumerable: true, get: function () { return mcp_1.createTicketTool; } });
+Object.defineProperty(exports, "noteTool", { enumerable: true, get: function () { return mcp_1.noteTool; } });
+Object.defineProperty(exports, "workflowTool", { enumerable: true, get: function () { return mcp_1.workflowTool; } });
+Object.defineProperty(exports, "resolveTool", { enumerable: true, get: function () { return mcp_1.resolveTool; } });
+Object.defineProperty(exports, "guardTool", { enumerable: true, get: function () { return mcp_1.guardTool; } });
+Object.defineProperty(exports, "MCP_SCHEMA_VERSION", { enumerable: true, get: function () { return mcp_1.MCP_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "MCP_SERVER_NAME", { enumerable: true, get: function () { return mcp_1.MCP_SERVER_NAME; } });
+//# sourceMappingURL=index.js.map