@peasant-labs/fairtrade 0.0.2 → 0.0.3

package/dist/lib/types/Intensity.d.ts

@@ -4,11 +4,11 @@ export function clampLevel(level: any): number;
  * coverage ratio (recorded / total) → ramp level. 0 / unknown = none; ≥ 0.9
  * reads as fully covered. mirrors peasant's traceabilityLevel quantiles.
  */
-export function coverageLevel(recorded: any, total: any): 0 | 4 | 1 | 2 | 3;
+export function coverageLevel(recorded: any, total: any): 0 | 1 | 2 | 3 | 4;
 /** density (0..1) → ramp level for the bottom-edge effort bar. */
-export function effortLevel(density: any): 0 | 4 | 1 | 2 | 3;
+export function effortLevel(density: any): 0 | 1 | 2 | 3 | 4;
 /** generic value-vs-max quantization (heatmap cells, sparklines). */
-export function quantize(value: any, max: any): 0 | 4 | 1 | 2 | 3;
+export function quantize(value: any, max: any): 0 | 1 | 2 | 3 | 4;
 /** loc → node size class. small files are compact; large ones get real estate. */
 export function locSize(loc: any): "sm" | "md" | "lg" | "xs" | "xl";
 export function IntensitySwatch({ level, accent, size, label, className, ...rest }: {

package/dist/lib/types/index.d.ts

@@ -21,6 +21,8 @@ export { default as GroupedMultiSelect } from "./GroupedMultiSelect.jsx";
 export { default as ToolCallRenderer } from "./ToolRenderers.jsx";
 export { default as Tour } from "./Tour.jsx";
 export { default as FacetRail } from "./FacetRail.jsx";
+export * from "./transcript/index.js";
+export * from "./transcript/graph/index.js";
 export { default as Button, ButtonGroup, Segmented } from "./Button.jsx";
 export { default as Input, Textarea, Select, Field } from "./Input.jsx";
 export { default as Checkbox, Radio, RadioGroup } from "./Checkbox.jsx";

package/dist/lib/types/transcript/CheckRow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {object} props
+ * @param {boolean} [props.checked]
+ * @param {Function} [props.onChange]   fired with the native change event
+ * @param {*} [props.children]          the row label (text, or icon + text)
+ * @param {number} [props.count]        optional trailing match count
+ * @param {boolean} [props.disabled]
+ */
+export default function CheckRow({ checked, onChange, children, count, disabled }: {
+    checked?: boolean;
+    onChange?: Function;
+    children?: any;
+    count?: number;
+    disabled?: boolean;
+}): any;

package/dist/lib/types/transcript/DiffEntryCard.d.ts

@@ -0,0 +1,27 @@
+/** @typedef {import('./view-model.js').DiffEntryVM} DiffEntryVM */
+/** @typedef {import('./view-model.js').DiffHunkVM} DiffHunkVM */
+/**
+ * Render cooked diff hunks as the canonical `.txn-diff` rows. The mockup draws a single
+ * `.diff` block per change, so hunks are flattened into one row list; each hunk's trailing
+ * empty line (the LCS newline artifact) is trimmed first.
+ * @param {object} props
+ * @param {DiffHunkVM[]} [props.hunks]
+ */
+export function DiffHunks({ hunks }: {
+    hunks?: DiffHunkVM[];
+}): any;
+/**
+ * One Diffs-tab card: a file/turn label, the +adds/−dels churn, a jump affordance, and the
+ * rendered diff hunks. Consumes a cooked `DiffEntryVM` (an entry of `vm.diffs`).
+ * @param {object} props
+ * @param {DiffEntryVM} [props.entry]
+ * @param {boolean} [props.byTurn]      label by turn index instead of file path
+ * @param {() => void} [props.onJump]
+ */
+export default function DiffEntryCard({ entry, byTurn, onJump }: {
+    entry?: DiffEntryVM;
+    byTurn?: boolean;
+    onJump?: () => void;
+}): any;
+export type DiffEntryVM = import("./view-model.js").DiffEntryVM;
+export type DiffHunkVM = import("./view-model.js").DiffHunkVM;

package/dist/lib/types/transcript/FilterSection.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object} props
+ * @param {*} [props.title]              the section heading (lowercase chrome)
+ * @param {*} [props.children]           the section body (rows)
+ * @param {boolean} [props.defaultOpen]
+ */
+export default function FilterSection({ title, children, defaultOpen }: {
+    title?: any;
+    children?: any;
+    defaultOpen?: boolean;
+}): any;

package/dist/lib/types/transcript/FiltersRail.d.ts

@@ -0,0 +1,41 @@
+export default function FiltersRail({ tab, filters, onFiltersChange, counts, checkpoints, filtersActive, onClear, onJumpStart, onJumpLatest, }: {
+    tab: any;
+    filters?: {
+        categories: {
+            prompts: boolean;
+            responses: boolean;
+            thinking: boolean;
+            toolcalls: boolean;
+        };
+        toolGroups: {};
+        tags: {
+            errors: boolean;
+            retries: boolean;
+            revert: boolean;
+        };
+        views: {
+            hidden: boolean;
+            expandAll: boolean;
+            compact: boolean;
+        };
+        checkpoint: string;
+    };
+    onFiltersChange?: () => void;
+    counts?: {
+        categories: {
+            prompts: number;
+            responses: number;
+            thinking: number;
+            toolcalls: number;
+        };
+        toolGroups: {};
+    };
+    checkpoints?: any[];
+    filtersActive?: number;
+    onClear?: () => void;
+    onJumpStart?: () => void;
+    onJumpLatest?: () => void;
+}): any;
+export type TranscriptFilters = import("./state-capabilities.js").TranscriptFilters;
+export type ToolGroup = import("./view-model.js").ToolGroup;
+export type CommitVM = import("./view-model.js").CommitVM;

package/dist/lib/types/transcript/LabelPopover.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {object} props
+ * @param {number} [props.turnId]                                  the turn index being labelled
+ * @param {SavedLabel} [props.current]                             the existing label, if any
+ * @param {(outcome: SavedLabel['outcome'], flag: string) => void} [props.onSave]
+ * @param {Function} [props.onClose]
+ */
+export default function LabelPopover({ turnId, current, onSave, onClose }: {
+    turnId?: number;
+    current?: SavedLabel;
+    onSave?: (outcome: SavedLabel["outcome"], flag: string) => void;
+    onClose?: Function;
+}): any;
+export type SavedLabel = import("./state-capabilities.js").SavedLabel;

package/dist/lib/types/transcript/Markdown.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {object} props
+ * @param {string} [props.text]   the cooked markdown body (e.g. `TurnVM.content`)
+ */
+export default function Markdown({ text }: {
+    text?: string;
+}): any;

package/dist/lib/types/transcript/OutlineRail.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {object} props
+ * @param {TranscriptViewModel} props.viewModel
+ * @param {import('./state-capabilities.js').TranscriptTab} props.tab
+ * @param {(turnIndex: number) => void} [props.onJump]
+ */
+export default function OutlineRail({ viewModel, tab, onJump }: {
+    viewModel: TranscriptViewModel;
+    tab: import("./state-capabilities.js").TranscriptTab;
+    onJump?: (turnIndex: number) => void;
+}): any;
+export type TranscriptViewModel = import("./view-model.js").TranscriptViewModel;
+export type AnnotationVM = import("./view-model.js").AnnotationVM;

package/dist/lib/types/transcript/Scorecard.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {object} props
+ * @param {ScorecardBandVM[]} [props.bands]   the cooked scorecard bands (vm.analytics.scorecardBands)
+ */
+export default function Scorecard({ bands }: {
+    bands?: ScorecardBandVM[];
+}): any;
+export type ScorecardBandVM = import("./view-model.js").ScorecardBandVM;

package/dist/lib/types/transcript/Scrubber.d.ts

@@ -0,0 +1,17 @@
+/** @typedef {import('./view-model.js').TurnVM} TurnVM */
+/**
+ * @param {object} props
+ * @param {TurnVM[]} [props.turns]
+ * @param {number} [props.active]                          the active TURN INDEX (TurnVM.index)
+ * @param {(clientX: number, track: HTMLElement) => void} [props.onSeek]
+ * @param {{ current: boolean }} [props.draggingRef]       shared drag latch; defaults to an internal ref
+ */
+export default function Scrubber({ turns, active, onSeek, draggingRef }: {
+    turns?: TurnVM[];
+    active?: number;
+    onSeek?: (clientX: number, track: HTMLElement) => void;
+    draggingRef?: {
+        current: boolean;
+    };
+}): any;
+export type TurnVM = import("./view-model.js").TurnVM;

package/dist/lib/types/transcript/TaskBody.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {object} props
+ * @param {ToolCallVM} [props.tool]
+ */
+export default function TaskBody({ tool }: {
+    tool?: ToolCallVM;
+}): any;
+export type ToolCallVM = import("./view-model.js").ToolCallVM;

package/dist/lib/types/transcript/Thinking.d.ts

@@ -0,0 +1,9 @@
+/** @typedef {import('./view-model.js').ThinkingVM} ThinkingVM */
+/**
+ * @param {object} props
+ * @param {ThinkingVM} [props.block]   cooked thinking (e.g. `TurnVM.thinking`)
+ */
+export default function Thinking({ block }: {
+    block?: ThinkingVM;
+}): any;
+export type ThinkingVM = import("./view-model.js").ThinkingVM;

package/dist/lib/types/transcript/ToolBody.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {object} props
+ * @param {ToolCallVM} [props.tool]
+ */
+export default function ToolBody({ tool }: {
+    tool?: ToolCallVM;
+}): any;
+export type ToolCallVM = import("./view-model.js").ToolCallVM;

package/dist/lib/types/transcript/ToolCall.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {object} props
+ * @param {ToolCallVM} [props.tool]
+ * @param {boolean} [props.open]
+ * @param {() => void} [props.onToggle]
+ */
+export default function ToolCall({ tool, open, onToggle }: {
+    tool?: ToolCallVM;
+    open?: boolean;
+    onToggle?: () => void;
+}): any;
+export type ToolCallVM = import("./view-model.js").ToolCallVM;

package/dist/lib/types/transcript/TranscriptViewer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {TranscriptViewerProps} props
+ */
+export default function TranscriptViewer({ viewModel, capabilities, callbacks, theme: themeProp, onThemeChange, graphSlot, activeTab: activeTabProp, onTabChange, viewMode: viewModeProp, onViewModeChange, leftRailOpen: leftRailOpenProp, onLeftRailOpenChange, rightRailOpen: rightRailOpenProp, onRightRailOpenChange, openTools: openToolsProp, onOpenToolsChange, activeTurn: activeTurnProp, onActiveTurnChange, search: searchProp, onSearchChange, filters: filtersProp, onFiltersChange, savedLabels: savedLabelsProp, onSavedLabelsChange, shareOpen: shareOpenProp, onShareOpenChange, moreOpen: moreOpenProp, onMoreOpenChange, }: TranscriptViewerProps): any;
+export type TranscriptViewerProps = import("./state-capabilities.js").TranscriptViewerProps;
+export type TranscriptFilters = import("./state-capabilities.js").TranscriptFilters;

package/dist/lib/types/transcript/TurnCard.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {object} props
+ * @param {TurnVM} [props.turn]
+ * @param {boolean} [props.active]
+ * @param {Record<string, boolean>} [props.openTools]   tool id → open?
+ * @param {(id: string) => void} [props.toggleTool]
+ * @param {(turnIndex: number) => void} [props.onCopyAnchor]
+ * @param {boolean} [props.copied]
+ * @param {(turnIndex: number, el: HTMLElement | null) => void} [props.registerRef]
+ * @param {(turnIndex: number) => void} [props.onLabel]   omit to hide the "label" affordance
+ * @param {{ outcome: string, flag?: string }} [props.savedLabel]
+ * @param {boolean} [props.compact]
+ * @param {boolean} [props.expandAll]
+ */
+export default function TurnCard({ turn, active, openTools, toggleTool, onCopyAnchor, copied, registerRef, onLabel, savedLabel, compact, expandAll, }: {
+    turn?: TurnVM;
+    active?: boolean;
+    openTools?: Record<string, boolean>;
+    toggleTool?: (id: string) => void;
+    onCopyAnchor?: (turnIndex: number) => void;
+    copied?: boolean;
+    registerRef?: (turnIndex: number, el: HTMLElement | null) => void;
+    onLabel?: (turnIndex: number) => void;
+    savedLabel?: {
+        outcome: string;
+        flag?: string;
+    };
+    compact?: boolean;
+    expandAll?: boolean;
+}): any;
+export type TurnVM = import("./view-model.js").TurnVM;

package/dist/lib/types/transcript/ViewSwitch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object} props
+ * @param {string} [props.label]      the switch label + its accessible name
+ * @param {boolean} [props.on]
+ * @param {Function} [props.onToggle]
+ */
+export default function ViewSwitch({ label, on, onToggle }: {
+    label?: string;
+    on?: boolean;
+    onToggle?: Function;
+}): any;

package/dist/lib/types/transcript/adapter.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Default turn prefilter the adapter applies to `payload.turns`: drop turns with
+ * neither content nor tool calls (and short tool-less system banners), then
+ * collapse adjacent same-role turns with identical content (a streaming
+ * artifact), preferring the tool-bearing copy. Pure, order-preserving. Exported
+ * so a host that pre-scopes turns can run the SAME filter.
+ * @param {TurnDetail[]} turns
+ * @returns {TurnDetail[]}
+ */
+export function prefilterTurns(turns: TurnDetail[]): TurnDetail[];
+/**
+ * Dependency-free line diff (LCS) → cooked `DiffLineVM[]`. fairtrade ships no
+ * `diff` package, so the adapter computes hunks itself. Line numbers are 1-based
+ * within the supplied snippet (the wire carries the edit snippet, not the file
+ * offset). Deterministic — no clock/randomness — so it is screenshot-stable.
+ * @param {string} oldText
+ * @param {string} newText
+ * @returns {DiffLineVM[]}
+ */
+export function diffLines(oldText: string, newText: string): DiffLineVM[];
+/**
+ * Project the canonical wire payload (folded turns) into the cooked
+ * `TranscriptViewModel` every dumb transcript component renders. The SOLE
+ * wire-parse + git-drift normalisation site.
+ *
+ * @param {TranscriptWireInput} payload          canonical wire; tolerates both git shapes
+ * @param {AnnotationSummary[]} [annotations]     separately-fetched entry annotations
+ * @param {TranscriptAnalyticsVM} [analytics]     precomputed analytics; else derived on demand
+ * @returns {TranscriptViewModel}
+ */
+export function adaptTranscript(payload: TranscriptWireInput, annotations?: AnnotationSummary[], analytics?: TranscriptAnalyticsVM): TranscriptViewModel;
+export type TranscriptWireInput = import("./wire-types.js").TranscriptWireInput;
+export type SessionDetailPayload = import("./wire-types.js").SessionDetailPayload;
+export type TurnDetail = import("./wire-types.js").TurnDetail;
+export type ToolCallDetail = import("./wire-types.js").ToolCallDetail;
+export type AnnotationSummary = import("./wire-types.js").AnnotationSummary;
+export type TranscriptViewModel = import("./view-model.js").TranscriptViewModel;
+export type TranscriptAnalyticsVM = import("./view-model.js").TranscriptAnalyticsVM;
+export type SessionVM = import("./view-model.js").SessionVM;
+export type SessionGitVM = import("./view-model.js").SessionGitVM;
+export type CommitVM = import("./view-model.js").CommitVM;
+export type TurnVM = import("./view-model.js").TurnVM;
+export type ToolCallVM = import("./view-model.js").ToolCallVM;
+export type ToolGroup = import("./view-model.js").ToolGroup;
+export type DiffLineVM = import("./view-model.js").DiffLineVM;
+export type DiffHunkVM = import("./view-model.js").DiffHunkVM;
+export type DiffEntryVM = import("./view-model.js").DiffEntryVM;
+export type FileEntryVM = import("./view-model.js").FileEntryVM;
+export type AnnotationVM = import("./view-model.js").AnnotationVM;
+export type HighlightVM = import("./view-model.js").HighlightVM;
+export type FilterIndexVM = import("./view-model.js").FilterIndexVM;
+export type PhaseVM = import("./view-model.js").PhaseVM;
+export type WireGitLike = {
+    branch?: string | null;
+    remote?: string | null;
+    /**
+     * TS-drift author (transcript.ts)
+     */
+    user?: string;
+    commits?: unknown[];
+};
+export type WireCommitLike = {
+    hash?: string;
+    message?: string;
+    /**
+     * Go shape (metadata.go)
+     */
+    authorName?: string;
+    /**
+     * Go shape, Unix millis
+     */
+    commitTime?: number;
+    /**
+     * TS-drift shape (transcript.ts)
+     */
+    timestamp?: string;
+    /**
+     * TS-drift per-commit churn
+     */
+    filesChanged?: number;
+    /**
+     * TS-drift per-commit churn
+     */
+    insertions?: number;
+    /**
+     * TS-drift per-commit churn
+     */
+    deletions?: number;
+    session?: boolean;
+};

package/dist/lib/types/transcript/adapter.parse.d.ts

@@ -0,0 +1,75 @@
+/** @typedef {import('./wire-types.js').ToolCallDetail} ToolCallDetail */
+/**
+ * The SOLE `JSON.parse` of a wire-encoded tool string in the lifted code. Every
+ * other parse helper here, the adapter, and the analytics util route through it,
+ * so a grep for `JSON.parse` of tool args/result yields exactly one hit. Returns
+ * `undefined` for empty or malformed input — callers degrade rather than throw.
+ *
+ * @param {string | undefined | null} raw
+ * @returns {unknown}
+ */
+export function parseJson(raw: string | undefined | null): unknown;
+/**
+ * Parse a tool call's `arguments` JSON string. Thin named entry point over the
+ * one `parseJson` site; the cooked `ToolCallVM.args` is this value (shape varies
+ * by tool, hence `unknown`).
+ * @param {string | undefined | null} raw
+ * @returns {unknown}
+ */
+export function parseArgs(raw: string | undefined | null): unknown;
+/**
+ * Parse a tool call's `result` JSON string. Thin named entry point over the one
+ * `parseJson` site; the cooked `ToolCallVM.output` is this value.
+ * @param {string | undefined | null} raw
+ * @returns {unknown}
+ */
+export function parseResult(raw: string | undefined | null): unknown;
+/**
+ * Extract the file path a tool call targets, preferring the wire `filePath`
+ * field and falling back to the common `file_path` / `path` / `notebook_path`
+ * argument keys. Consolidates the THREE duplicate `extractPath` definitions
+ * (tasks.ts, FilesView.tsx, file-rollup.ts) into one.
+ * @param {ToolCallDetail} call
+ * @returns {string | undefined}
+ */
+export function extractPath(call: ToolCallDetail): string | undefined;
+/**
+ * One old→new replacement inside an Edit / MultiEdit / NotebookEdit call.
+ * @typedef {object} EditPair
+ * @property {string} old_string
+ * @property {string} new_string
+ */
+/**
+ * The list of old→new replacements for an edit-family tool call: the `edits[]`
+ * array for MultiEdit, else the single `old_string` / `new_string` pair. Used by
+ * BOTH the diff-hunk builder (adapter) and the churn counter (`countDiff`), so
+ * the argument shape is parsed in exactly one place.
+ * @param {ToolCallDetail} call
+ * @returns {EditPair[]}
+ */
+export function editPairs(call: ToolCallDetail): EditPair[];
+/**
+ * The full-file body a Write tool call lays down (its `content` argument).
+ * @param {ToolCallDetail} call
+ * @returns {string}
+ */
+export function writeContent(call: ToolCallDetail): string;
+/**
+ * Lines inserted / removed for an edit-family or write tool call. Consolidates
+ * the THREE duplicate `countDiff` definitions. Pure: depends only on the parsed
+ * arguments, never a clock or the file system.
+ * @param {ToolCallDetail} call
+ * @returns {{ adds: number, dels: number }}
+ */
+export function countDiff(call: ToolCallDetail): {
+    adds: number;
+    dels: number;
+};
+export type ToolCallDetail = import("./wire-types.js").ToolCallDetail;
+/**
+ * One old→new replacement inside an Edit / MultiEdit / NotebookEdit call.
+ */
+export type EditPair = {
+    old_string: string;
+    new_string: string;
+};