@bendyline/gezel 0.1.0

package/dist/markdown/index.d.ts

@@ -0,0 +1,174 @@
+import { C as CraftbookDocError, a as CraftbookDoc, P as ParsedGezel, R as ParsedReportAction, X as ReportActionParseIssue } from '../report-action-DzdQHzGG.js';
+import 'zod';
+
+interface CraftbookMarkdownParse {
+    ok: boolean;
+    doc?: Record<string, unknown>;
+    errors: CraftbookDocError[];
+}
+/**
+ * Parse markdown into the RAW doc object (not yet schema-validated — the
+ * caller runs `CraftbookDocSchema.parse` so both encodings share one
+ * validation + error pipeline). Structural problems (bad frontmatter, a
+ * step block that doesn't parse, a script section without a fence) are
+ * reported here with the section heading as the location.
+ */
+declare function parseCraftbookMarkdown(text: string): CraftbookMarkdownParse;
+/** Serialize a schema-valid doc to the markdown encoding. */
+declare function serializeCraftbookMarkdown(doc: CraftbookDoc): string;
+/** Default step id used by both codecs when a step block omits `id`. */
+declare function defaultStepIdForName(name: string): string;
+
+/**
+ * Parse an `agent.md` source string into frontmatter + sections.
+ *
+ * Sections are split on top-level headings (the lowest heading level used in
+ * the document). Each section's heading may carry a template annotation —
+ * `### Memory {[memory color=blue]}` — matching the Squisq editor convention.
+ * We extract the template name and key=value params and store the clean
+ * heading text.
+ */
+declare function parseGezelMarkdown(source: string): ParsedGezel;
+/**
+ * Serialize a ParsedGezel back to markdown and reconstruct sections with
+ * their template annotations.
+ */
+declare function serializeGezelMarkdown(parsed: ParsedGezel): string;
+
+/**
+ * ─ Fence-aware markdown structure helpers ────────────────────────────
+ *
+ * Shared low-level machinery for markdown formats that must never be
+ * fooled by code fences: the craftbook markdown codec
+ * ([craftbook-md.ts](./craftbook-md.ts)) and the skill-document parser
+ * ([../skills/](../skills/)). A `## ` heading or `# ` title inside a
+ * fenced block (a script source, a bash example) is content, not
+ * structure — every helper here honors that.
+ *
+ * Extracted verbatim from craftbook-md.ts so the skill
+ * parser could reuse it; behavior is byte-identical for the codec.
+ */
+declare const FENCE: RegExp;
+interface MdSection {
+    heading: string;
+    body: string;
+}
+/**
+ * Split content on `## ` headings, fence-aware: a `## ` inside a code
+ * fence never starts a section. Content before the first heading is the
+ * preamble.
+ */
+declare function splitSections(lines: string[]): {
+    preamble: string;
+    sections: MdSection[];
+};
+/**
+ * The first fence-aware H1 (`# <title>`) in the text: returns its line
+ * index and title, or null. Bash comments inside fenced preamble blocks
+ * look exactly like H1s — the fence tracking is what makes generated
+ * skill preamble stripping safe.
+ */
+declare function findFirstH1(lines: string[]): {
+    index: number;
+    title: string;
+} | null;
+/** The first fenced code block's body (any tag), or undefined. */
+declare function extractFirstFence(body: string): string | undefined;
+/**
+ * Every fenced code block in `body`, in document order, with its tag
+ * (lowercased) and content. Unclosed trailing fences are dropped rather
+ * than guessed at.
+ */
+declare function extractAllFences(body: string): Array<{
+    lang: string;
+    code: string;
+}>;
+/** True when `line` closes a fence opened with `marker` (same char, at least as long, no tag). */
+declare function isFenceClose(line: string, marker: string): boolean;
+/** Parse a YAML fence body as an in-memory mapping. */
+declare function parseYamlBlock(yamlText: string): Record<string, unknown>;
+/** Stringify fields as a YAML block body (trailing newline included). */
+declare function stringifyYamlBlock(fields: Record<string, unknown>): string;
+/** A fence long enough that the source's own backtick runs can't close it early. */
+declare function pickFence(source: string): string;
+
+/**
+ * Promote bare channel-name leaks (Gemma 4 26B and gpt-oss family
+ * tic) to italic mode indicators. The model emits the bare channel
+ * name on its own line — sometimes 50+ times in a row — when its
+ * `<|channel|>` markup gets garbled at decode time. Without
+ * promotion these `thought\n` / `analysis\n` / `commentary\n` /
+ * `final\n` lines bleed into the visible bubble exactly as the
+ * model emitted them.
+ *
+ * Shared between:
+ *   - `packages/service` `reasoning.strip-channel-tags` behavior —
+ *     runs at message-commit time on the final assistant text.
+ *   - `packages/ui` StreamingBubble — runs at stream-render time so
+ *     the user sees `_Thinking…_` even mid-stream, never the raw
+ *     `thought\n` leak.
+ *
+ * Mode mappings:
+ *   `thought`     → `_Thinking…_`
+ *   `analysis`    → `_Analyzing…_`
+ *   `commentary`  → `_Reflecting…_`
+ *   `final`       → dropped (it just signals "the real reply starts
+ *                   here"; the user doesn't need a status line for
+ *                   "model is now replying")
+ *
+ * Consecutive identical leaks collapse to ONE indicator so 50
+ * `thought\n` lines produce one `_Thinking…_`. A non-leak line
+ * resets the run state so a later `thought` after real content
+ * emits a fresh indicator.
+ */
+declare function promoteBareChannelNames(text: string): string;
+
+/**
+ * ```gezel-action fence parsing — the read half of report actions.
+ *
+ * Deliberately tolerant, mirroring `parseCraftbookTestSpec`'s posture:
+ * these blocks are authored by models overnight, so a malformed block
+ * must surface as a visible, debuggable ISSUE — never a thrown error and
+ * never a silently vanished action. Unknown keys are stripped, common
+ * kind spellings are aliased, scalar params are string-coerced.
+ *
+ * Isomorphic: the UI parses individual fence bodies (fed squisq code
+ * nodes) with `parseReportActionBlock`; the service parses whole
+ * documents with `parseReportActions`. Identity resolution is shared, so
+ * both sides agree on ids — FNV-1a (not node:crypto) keeps it
+ * browser-safe.
+ */
+declare const REPORT_ACTION_FENCE_LANG = "gezel-action";
+interface ParsedReportActions {
+    actions: ParsedReportAction[];
+    issues: ReportActionParseIssue[];
+}
+/** FNV-1a 32-bit hex of a string — stable, tiny, dependency-free. */
+declare function reportActionContentHash(body: string): string;
+/**
+ * Parse one fence body. Never throws; returns a structured issue on any
+ * failure so the block stays visible.
+ */
+declare function parseReportActionBlock(body: string, index: number): {
+    ok: true;
+    action: ParsedReportAction;
+} | {
+    ok: false;
+    issue: ReportActionParseIssue;
+};
+/**
+ * Parse every gezel-action fence in a markdown document. Duplicate
+ * resolved ids get `-2`, `-3`… suffixes plus a diagnostic issue, so two
+ * sloppy blocks can't silently share lifecycle state.
+ */
+declare function parseReportActions(markdown: string): ParsedReportActions;
+/** Whether a document contains any gezel-action fence (cheap pre-check). */
+declare function hasReportActionFence(markdown: string): boolean;
+/**
+ * The prompt snippet that teaches a report-writing gezel the format.
+ * Embedded in the night-shift oversight prompt and referenced by the
+ * gilde authoring guidelines — one source, no drift.
+ */
+declare const REPORT_ACTION_AUTHORING_GUIDE = "When a recommendation is directly actionable, follow it with a ```gezel-action fenced YAML block so the user can fire it with one click in the morning. Three kinds, flat keys only, one block per action, each with a unique stable `id` slug:\n\nRun an existing craftbook:\n```gezel-action\nkind: fire-craftbook\nid: nightly-a11y-sweep\ntitle: Run an accessibility audit\nreason: Three templates changed without alt text review.\ncraftbookId: a11y-audit\nprojectId: webshop\n```\n\nDelegate a bespoke task:\n```gezel-action\nkind: create-task\nid: fix-null-parse\ntitle: Fix the unchecked null in parser.ts\nreason: parseHeader returns null on empty input and callers dereference it.\nprompt: In src/parser.ts, parseHeader can return null (line ~88) and both callers dereference the result. Add the guard, mirror the fix in parseFooter, and extend parser.test.ts with the empty-input case.\nrole: software developer\nprojectId: webshop\n```\n\nPropose file edits (diffs go in SIDECAR artifact files \u2014 never inline):\n```gezel-action\nkind: apply-edits\nid: harden-csp-headers\ntitle: Add missing security headers\nreason: Responses lack X-Content-Type-Options and a CSP.\nprojectId: webshop\nedits:\n  - path: src/server/headers.ts\n    diffArtifact: night-shift-report/edits/harden-csp-headers.diff\n```\n\nFor apply-edits: write each proposed change as ONE unified diff per target file with write_artifact (a single-file diff against the file's current content), and reference it via diffArtifact. Keep titles short, reasons to a sentence or two, and never invent craftbook ids \u2014 only reference books you confirmed exist.";
+
+export { type CraftbookMarkdownParse, FENCE, type MdSection, type ParsedReportActions, REPORT_ACTION_AUTHORING_GUIDE, REPORT_ACTION_FENCE_LANG, defaultStepIdForName, extractAllFences, extractFirstFence, findFirstH1, hasReportActionFence, isFenceClose, parseCraftbookMarkdown, parseGezelMarkdown, parseReportActionBlock, parseReportActions, parseYamlBlock, pickFence, promoteBareChannelNames, reportActionContentHash, serializeCraftbookMarkdown, serializeGezelMarkdown, splitSections, stringifyYamlBlock };