@buildaharness/aielia 0.3.9 → 0.3.10

package/dist/writer/article-outline.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The outline of the text as it is now: the headings with their numbers. Drawn from the text itself (not from saved sections), so it follows the
+ * writer while typing, and a heading renamed in the outline is a change of the text, which is where the heading lives.
+ */
+export interface OutlineEntry {
+    /** "1", "1.2", … Empty for the title (a single top-level heading at the start). */
+    number: string;
+    heading: string;
+    level: number;
+    /** Depth below the title, 0 for the top. */
+    depth: number;
+    /** Where the heading line starts in the text. */
+    start: number;
+    /** Where the section ends: just before the next heading of any level. */
+    end: number;
+}
+export declare function outlineOf(markdown: string): OutlineEntry[];
+/** The text with the heading line that starts at `start` given a new wording; its level (the hashes) is kept. Unchanged when the new wording is empty. */
+export declare function renameHeadingInText(markdown: string, start: number, heading: string): string;
+/** The outline as plain text the writer edits: one heading per line, written the way it is in the article (`## Name`). */
+export declare function outlineToText(markdown: string): string;
+/**
+ * The article after the writer edited its outline as text. A heading kept as it was keeps its section; a heading reworded or moved to another
+ * level keeps its section too (matched in order, within the gap between unchanged headings); a heading moved to another place takes its section
+ * with it; a new line is a new, empty section; a deleted line removes the heading only, its text stays with the section above. Returns the
+ * article unchanged while a line is only hashes.
+ */
+export declare function applyOutlineText(markdown: string, outlineText: string): string;
+/**
+ * Growing a selection in the outline text: the heading line, then that heading with the headings under it, then the heading it sits under with
+ * everything under that, and so on up. The whole outline is never offered, so the largest selection is the one just below it. `range` is in the
+ * outline text (`outlineToText`), not in the article.
+ */
+export declare function expandOutlineSelection(outlineText: string, range: {
+    start: number;
+    end: number;
+}): {
+    range: {
+        start: number;
+        end: number;
+    };
+    unit: 'heading' | 'section';
+} | undefined;

package/dist/writer/article-resolver.d.ts

@@ -0,0 +1,55 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+import { ArticleMeta, Link } from './article-model.js';
+/**
+ * The resolver (T4, T5, T6): after something changes, a model judges what else is affected. Stored links only choose
+ * where to look first; the model reads every section's heading and opening and may find effects, and propose links,
+ * beyond them. Every judgement of meaning is the model's; this module validates the ids it returns, applies the rules
+ * (the resolver can mark a section needs-review but never clear it, and never touches a confirmed or hand-drawn link)
+ * and reports what it did. A failure leaves the article as it was and says so.
+ */
+export type Change = {
+    kind: 'text_edited';
+    sectionIds: string[];
+    summary: string;
+} | {
+    kind: 'correction';
+    note: string;
+    supersedes?: string;
+};
+export interface ResolveResult {
+    status: 'resolved' | 'not_resolved';
+    meta: ArticleMeta;
+    flagged: {
+        sectionId: string;
+        reason: string;
+    }[];
+    proposedLinks: Link[];
+    /** Model suggestions that named an id that does not exist, or a rule refused. Reported, not applied. */
+    skipped: string[];
+}
+/** Section ids connected to the changed ones by a rests_on or repeats link, in either direction. */
+export declare function linkedSectionIds(meta: ArticleMeta, changed: readonly string[]): Set<string>;
+export declare function resolveChange(input: {
+    meta: ArticleMeta;
+    markdown: string;
+    change: Change;
+    now: string;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<ResolveResult>;
+export interface SourceImpact {
+    claimId: string;
+    impact: 'none' | 'recheck' | 'likely_wrong';
+    reason: string;
+}
+export interface SourceChangeResult {
+    status: 'assessed' | 'not_assessed';
+    meta: ArticleMeta;
+    impacts: SourceImpact[];
+}
+/** Whether a changed source matters to the claims that cite it. A claim that matters gets needsRecheck; a likely wrong one also flags its section. */
+export declare function assessSourceChange(input: {
+    meta: ArticleMeta;
+    sourceId: string;
+    before: string;
+    after: string;
+    now: string;
+}, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void): Promise<SourceChangeResult>;

package/dist/writer/article-revisions.d.ts

@@ -0,0 +1,30 @@
+import { SelectionRange, SelectionUnit } from './article-selection.js';
+/**
+ * The revisions of one piece of the text (a sentence, a paragraph or a section): how that piece read in each saved version. The piece is the unit
+ * the selection is (see `unitOfSelection`). In an older version the same piece is the unit of the same kind that shares the most words with it, so
+ * a reworded sentence is still found; when nothing shares enough, the piece was not in that version. Pure; versions come from the article's snapshots.
+ */
+export interface VersionText {
+    index: number;
+    kind: string;
+    label?: string;
+    at: string;
+    markdown: string;
+}
+export interface TextRevision {
+    /** The version, or undefined for the text as it is now. */
+    index?: number;
+    kind?: string;
+    label?: string;
+    at?: string;
+    /** How the piece read then; undefined when it was not in that version. */
+    text: string | undefined;
+}
+export interface TextRevisions {
+    unit: SelectionUnit;
+    now: string;
+    /** Newest first, starting with now, and only where the wording differs from the revision before it. */
+    revisions: TextRevision[];
+}
+/** `versions` in any order. */
+export declare function revisionsOfText(markdown: string, range: SelectionRange, versions: readonly VersionText[]): TextRevisions | undefined;

package/dist/writer/article-rules.d.ts

@@ -0,0 +1,60 @@
+import { ArticleMeta, Claim, Section, Source, SourceStatus } from './article-model.js';
+/**
+ * The rules the article model must always keep (plans/aielia_write_article_model_plan.html, section 9), as pure functions.
+ * Each returns a new value or a refusal with a reason; none mutates its input, and none deletes silently.
+ */
+export type Actor = 'writer' | 'resolver' | 'assistant' | 'editor';
+export type Refusal = {
+    ok: false;
+    reason: string;
+};
+/**
+ * What a claim's source status may be shown as. A check only counts if it ran on the claim's current text against the
+ * current stored passages; otherwise the verdict is not shown as supported (not_checked), or stale when a source changed.
+ */
+export declare function effectiveSourceStatus(claim: Claim, sources: readonly Source[]): SourceStatus;
+/** Changing a claim's text resets its check result. */
+export declare function editClaimText(claim: Claim, quote: string, by: 'model' | 'writer', now: string): Claim;
+/** The resolver may mark a section needs review; it cannot mark it clean. Only the writer clears it. */
+export declare function setSectionReview(meta: ArticleMeta, sectionId: string, state: Section['review']['state'], reason: string | undefined, by: Actor, now: string): {
+    ok: true;
+    meta: ArticleMeta;
+} | Refusal;
+/** Confirmed and hand-drawn links are never changed or removed by the assistant; it can only propose a change. */
+export declare function removeLink(meta: ArticleMeta, linkId: string, by: Actor): {
+    ok: true;
+    meta: ArticleMeta;
+} | Refusal;
+export declare function confirmLink(meta: ArticleMeta, linkId: string, by: Actor): {
+    ok: true;
+    meta: ArticleMeta;
+} | Refusal;
+export interface Problem {
+    where: string;
+    message: string;
+}
+/** Every id referenced by a link, comment, claim or suggestion must exist. Broken records are reported and kept, never deleted. */
+export declare function checkIntegrity(meta: ArticleMeta): Problem[];
+export interface Readiness {
+    unsourcedFactualClaims: number;
+    staleOrUnsupportedClaims: number;
+    openComments: number;
+    sectionsNeedingReview: number;
+}
+/** Computed, never stored by hand (D3: warn only). Publishing is allowed regardless; a snapshot records these counts. */
+export declare function computeReadiness(meta: ArticleMeta): Readiness;
+export interface Snapshot {
+    readonly kind: 'published' | 'checkpoint';
+    readonly label?: string;
+    readonly at: string;
+    readonly markdown: string;
+    readonly meta: ArticleMeta;
+    readonly readiness: Readiness;
+}
+/** A snapshot is a frozen deep copy: later edits to the working article cannot change it. */
+export declare function createSnapshot(kind: Snapshot['kind'], markdown: string, meta: ArticleMeta, now: string, label?: string): Snapshot;
+/** Restoring creates a new working version from the snapshot; the snapshot itself and the history are untouched. */
+export declare function restoreSnapshot(snapshot: Snapshot): {
+    markdown: string;
+    meta: ArticleMeta;
+};

package/dist/writer/article-sections.d.ts

@@ -0,0 +1,26 @@
+import { Section } from './article-model.js';
+/**
+ * Sections from the Markdown (headings define sections) and their re-anchoring after the text changes. Structure only:
+ * a section keeps its id when its heading is unchanged, or when it is the one heading that changed in an otherwise
+ * unchanged outline. Anything less certain gets a new id and the old record is reported as removed, never dropped silently.
+ */
+export interface ParsedHeading {
+    heading: string;
+    level: number;
+    start: number;
+    end: number;
+}
+/** ATX headings outside fenced code. Text before the first heading becomes a level-0 "lead" section when it is not blank. */
+export declare function parseSections(markdown: string): ParsedHeading[];
+export interface ReconcileResult {
+    sections: Section[];
+    /** Ids kept, with the new heading when it was renamed. */
+    kept: {
+        id: string;
+        renamedFrom?: string;
+    }[];
+    created: string[];
+    /** Previous sections that no longer match anything; shown to the writer, not deleted without that. */
+    removed: Section[];
+}
+export declare function reconcileSections(previous: readonly Section[], markdown: string, newId: (taken: ReadonlySet<string>) => string): ReconcileResult;

package/dist/writer/article-selection.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Growing a selection by units of writing: a sentence, then the paragraph, then the section (a heading and everything under it, down to the next
+ * heading of the same or a higher level), then the whole article. Each step is the next unit that strictly contains the current selection, so a
+ * word, a sentence and several sentences all grow sensibly. Pure; the page keeps the earlier selections to shrink back. Units are found in the text
+ * as it is now (not from saved sections), so they are right while the writer is typing.
+ */
+export type SelectionUnit = 'sentence' | 'paragraph' | 'section' | 'article';
+export interface SelectionRange {
+    start: number;
+    end: number;
+}
+/**
+ * The next larger unit around the selection, or undefined when the whole article is already selected. With `wholeArticle: false` the whole article
+ * is never offered (nor a section that is all of it), so the largest selection is the one just below it: the writer then starts over from the sentence.
+ */
+export declare function expandSelection(text: string, range: SelectionRange, options?: {
+    wholeArticle?: boolean;
+}): {
+    range: SelectionRange;
+    unit: SelectionUnit;
+} | undefined;
+/** The unit the selection is: a selection that is exactly a sentence, paragraph or section is that unit; a cursor or a phrase is the sentence around it; anything longer, the smallest unit that holds it. */
+export declare function unitOfSelection(text: string, range: SelectionRange): {
+    range: SelectionRange;
+    unit: SelectionUnit;
+} | undefined;