@markmo/europacore-session-ui 0.3.0 → 0.4.0

package/dist/features/chat/model/memoryRecords.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Long-term memories as the memories screen shows them: its scopes and smart views, the rows each shows, the
+ * text of a flag, and the markdown a memory is edited as. Pure: no client, no browser. Not the decision register
+ * (`model/memory.ts`), which is the client's own. A port of europacorecli's `src/state/memory-records.ts`.
+ */
+import type { MemoryFlag, MemoryFlagName, MemoryPatch, MemoryRecord, MemoryRecordKind, MemoryRevision, MemoryScopeName } from '../../../api/wire';
+export declare const MEMORY_SCOPES: MemoryScopeName[];
+export declare const MEMORY_KINDS: MemoryRecordKind[];
+/** The caps the server enforces, checked here too so an edit is refused before it is sent. */
+export declare const DESCRIPTION_MAX = 200;
+export declare const BODY_MAX = 4000;
+export type SmartView = MemoryFlagName | 'forgotten';
+/** The smart views, by flag; "forgotten" lists the merged and pruned memories, which restore brings back. */
+export declare const SMART_VIEWS: {
+    view: SmartView;
+    label: string;
+}[];
+/** How each flag is written: a word when there is room, a letter when not. */
+export declare const FLAG_TEXT: Record<MemoryFlagName, {
+    word: string;
+    letter: string;
+    label: string;
+}>;
+/** One line of the scopes pane: everything, one scope (one project), or a smart view. */
+export interface ScopeNode {
+    id: string;
+    kind: 'all' | 'scope' | 'view';
+    label: string;
+    /** Null for a project not loaded yet. */
+    count: number | null;
+    scope?: MemoryScopeName;
+    project?: string | null;
+    view?: SmartView;
+}
+export declare function isActive(record: MemoryRecord): boolean;
+export declare function hasFlag(record: MemoryRecord, flag: MemoryFlagName): boolean;
+/** A project id's label: "project markmo/europacore". */
+export declare function projectLabel(project: string): string;
+/**
+ * The scopes pane: all memories, the org, the user, each project (the session's first, then the other projects
+ * the caller has memories in), then the smart views. Counts are of active memories; a project not loaded has none.
+ */
+export declare function scopeNodes(records: MemoryRecord[], labels: Partial<Record<MemoryScopeName, string>>, projects: string[], loaded: ReadonlySet<string>): ScopeNode[];
+/** Whether `record` matches a filter: every word in its name, description or body; `k:kind`, `s:source`. */
+export declare function matchesQuery(record: MemoryRecord, query: string): boolean;
+/**
+ * The rows `node` shows, in the index's order (scope, kind, name). `keep` holds memories changed here, which stay
+ * where they were whatever their status now, so forgetting one does not make it vanish from under the cursor.
+ */
+export declare function recordsFor(node: ScopeNode, records: MemoryRecord[], query: string, keep?: ReadonlySet<string>): MemoryRecord[];
+/** The flags column: the words when they fit `width`, else their letters. */
+export declare function flagCell(record: MemoryRecord, width: number): string;
+/** What a flag means for this memory, for its callout. */
+export declare function flagCallout(flag: MemoryFlag): string;
+/** When the memory reaches a model. */
+export declare function loadsWhen(record: MemoryRecord): string;
+/** Who wrote it, in which session, and when. */
+export declare function writtenBy(record: MemoryRecord, now?: number): string;
+/** A memory as `$EDITOR` shows it, parsed back. */
+export interface ParsedMemoryMarkdown {
+    name: string | null;
+    description: string;
+    kind: MemoryRecordKind;
+    body: string;
+}
+/**
+ * The markdown the server renders a memory as (`name`, `description` and `type` in the frontmatter, then the
+ * body), parsed back with the server's own rules, but strictly: what the server would quietly repair (a missing
+ * frontmatter, a description too long) is an error here, so an edit never saves something the person did not see.
+ */
+export declare function parseMemoryMarkdown(text: string): ParsedMemoryMarkdown | {
+    error: string;
+};
+/** The change an edit makes, against the revision it was read at; null when nothing changed. */
+export declare function memoryPatch(current: MemoryRecord, parsed: ParsedMemoryMarkdown): MemoryPatch | null | {
+    error: string;
+};
+/** What one revision changed, a line per field. */
+export declare function revisionChanges(revision: MemoryRevision): string[];

package/dist/features/chat/model/monitors.d.ts

@@ -0,0 +1,11 @@
+import type { MonitorEnd, MonitorOutput } from '../../../api/wire';
+import type { MonitorEntry } from './entries';
+/**
+ * A monitor's output as the server sends it (a `monitor_output` event's data, or a `monitor` notice's `monitor`),
+ * or null when it lacks what a row needs.
+ */
+export declare function monitorOutputOf(data: unknown): MonitorOutput | null;
+/** The transcript row for what the agent was given of a monitor's output. */
+export declare function monitorEntry(key: string, output: MonitorOutput): MonitorEntry;
+/** How a monitor ended, in a phrase: "its command exited with code 1 after 12s (3 events): Traceback…". */
+export declare function monitorEndText(end: MonitorEnd, files: boolean): string;

package/dist/features/chat/model/progress.d.ts

@@ -0,0 +1,73 @@
+import type { ViewState } from './store';
+export type StepStatus = 'completed' | 'in_progress' | 'pending';
+export interface ProgressStep {
+    text: string;
+    status: StepStatus;
+}
+/** A page the session wrote; never its viewer url, which carries a token. */
+export interface ArtifactOutput {
+    id: string;
+    title: string;
+    format: string;
+    version: number;
+    published: boolean;
+}
+export interface PullRequestOutput {
+    number: number;
+    state: 'open' | 'merged' | 'closed';
+    hint: string;
+    ready: boolean;
+}
+/** A file the agent wrote: its writes summed, which can be more than the net change. */
+export interface FileOutput {
+    path: string;
+    added: number;
+    deleted: number;
+    writes: number;
+}
+export interface Progress {
+    steps: ProgressStep[];
+    done: number;
+    artifacts: ArtifactOutput[];
+    pullRequests: PullRequestOutput[];
+    files: FileOutput[];
+    /** Web search queries, each once, in the order first asked. */
+    searches: string[];
+    sites: {
+        host: string;
+        fetches: number;
+    }[];
+    connectors: {
+        server: string;
+        calls: number;
+    }[];
+    skills: string[];
+    /** Skills loaded whose name the server did not send. */
+    unnamedSkills: number;
+    /** Images sent with the session's turns. */
+    images: number;
+}
+export declare const EMPTY_PROGRESS: Progress;
+/** The host a fetched url is on, without `www.`; null for anything that is not a web address. */
+export declare function hostOf(url: string): string | null;
+/** The server an MCP tool belongs to: `mcp__github__search_issues` is github's. */
+export declare function mcpServerOf(toolName: string): string | null;
+export declare function progressOf(state: Pick<ViewState, 'plan' | 'session' | 'entries'>): Progress;
+/** Nothing to show yet: no step, no output and no source. */
+export declare function isEmptyProgress(p: Progress): boolean;
+/**
+ * Whether a change to the view can change its progress: the plan, the session's metadata, a reload, or a turn or
+ * tool call. Streamed text only touches assistant entries and the run, so it never does.
+ */
+export declare function touchesProgress(changed: ReadonlySet<string>): boolean;
+/**
+ * Which of a plan's steps to show, at most `max`: from `before` steps ahead of the first one not done. The done steps
+ * ahead of the window are counted rather than shown. `fill` moves the window back to use all of `max` when the plan
+ * ends sooner, so a short plan shows whole.
+ */
+export declare function stepWindow(items: readonly {
+    status: string;
+}[], max: number, before?: number, fill?: boolean): {
+    start: number;
+    end: number;
+};

package/dist/features/chat/model/tasks.d.ts

@@ -3,7 +3,7 @@ import type { ToolEntry } from './entries';
 import type { SessionStore } from './store';
 /** Entry keys of background tasks: they outlive the run that started them. */
 export declare const TASK_KEY_PREFIX = "task:";
-/** True for an entry that stands for a background command or sub-agent. */
+/** True for an entry that stands for a background command, sub-agent or monitor. */
 export declare function isBackgroundTask(entry: {
     key: string;
 }): boolean;

package/dist/features/chat/panels/ProgressPanel.d.ts

@@ -0,0 +1,8 @@
+import type { SessionController } from '../session/SessionController';
+/**
+ * The session's progress (europacorecli's progress panel): the plan's steps, what the agent made (pages, pull
+ * requests, files) and what it used on the way (searches, sites, MCP connectors, skills, images).
+ */
+export declare function ProgressPanel({ controller }: {
+    controller: SessionController;
+}): import("react").JSX.Element;

package/dist/features/chat/session/SessionController.d.ts

@@ -1,12 +1,13 @@
 import { type ServerCommand } from '../../../api/agentClient';
-import type { AgentInfo, FormField, ImageInput, McpServer, Pause, QuestionAnswers, Run, Session, Stage } from '../../../api/wire';
+import type { AgentInfo, Envelope, FormField, ImageInput, McpServer, Pause, QuestionAnswers, Run, Session, Stage } from '../../../api/wire';
 import { type FleetParent } from '../model/fleet';
 import { SessionStore } from '../model/store';
 /** What /continue sends when it is given no instructions of its own. */
 export declare const CONTINUE_PROMPT = "Continue where you left off.";
 /** What /recap sends. */
 export declare const RECAP_PROMPT = "In two or three lines, recap this session: the goal, what has been decided so far, and what remains. Reply with only the recap.";
-/** Keys of the controller's own state, reported alongside the store's. */
+/** Hear every event of every followed session; the returned function stops. */
+export declare function onSessionEnvelope(listener: (sessionId: string, env: Envelope) => void): () => void;
 export declare const LOCAL: {
     readonly followUps: "@followUps";
     readonly images: "@images";

package/dist/features/chat/session/useFileMentions.d.ts

@@ -1,7 +1,20 @@
+import type { ArtifactInfo } from '../../../api/wire';
 import type { SessionController } from './SessionController';
-/** The `@query` at the end of the draft, when it is typing a file mention. */
+/** A completion for `@`: what goes after the `@`, and how the list shows it. */
+export interface Mention {
+    value: string;
+    label: string;
+    detail?: string;
+    kind: 'file' | 'artifact';
+}
+/** The `@query` at the end of the draft, when it is typing a mention. */
 export declare function mentionQuery(draft: string): string | null;
-/** `draft` with its trailing `@query` replaced by `@path `. */
-export declare function insertMention(draft: string, path: string): string;
-/** Files of the session's workspace matching the `@query` being typed (the app's `WorkspaceService.files`). */
-export declare function useFileMentions(controller: SessionController, query: string | null): string[];
+/** `draft` with its trailing `@query` replaced by `@value `. */
+export declare function insertMention(draft: string, value: string): string;
+/** The artifacts matching `query`, as mentions: `@artifact:<id>`, which the agent reads with `artifact_read`. */
+export declare function artifactMentions(list: ArtifactInfo[], query: string, limit: number): Mention[];
+/**
+ * What `@query` completes: the session's workspace files (the app's `WorkspaceService.files`), then the artifacts
+ * whose title, id or description match; `@artifact:` completes only artifacts.
+ */
+export declare function useFileMentions(controller: SessionController, query: string | null): Mention[];

package/dist/features/chat/transcript/ArtifactCard.d.ts

@@ -0,0 +1,8 @@
+import type { ArtifactDeletedDisplay, ArtifactDisplay } from '../../../api/wire';
+export declare function ArtifactCard({ display: d, sessionId }: {
+    display: ArtifactDisplay;
+    sessionId: string | null;
+}): import("react").JSX.Element;
+export declare function ArtifactDeletedCard({ display: d }: {
+    display: ArtifactDeletedDisplay;
+}): import("react").JSX.Element;

package/dist/features/chat/transcript/Rows.d.ts

@@ -1,5 +1,5 @@
 import { type PlanItem } from '../../../api/wire';
-import type { AssistantEntry, DecisionEntry, DiffEntry, NoticeEntry, RunEndEntry, SteerEntry, ToolEntry, UserEntry, WakeEntry } from '../model/entries';
+import type { AssistantEntry, DecisionEntry, DiffEntry, MonitorEntry, NoticeEntry, PeerEntry, RunEndEntry, SteerEntry, ToolEntry, UserEntry, WakeEntry } from '../model/entries';
 import type { SessionController } from '../session/SessionController';
 export declare const UserRow: import("react").NamedExoticComponent<{
     controller: SessionController;
@@ -49,6 +49,17 @@ export declare function RunEndRow({ entry }: {
 export declare function WakeRow({ entry }: {
     entry: WakeEntry;
 }): import("react").JSX.Element;
+/** A message from another session's agent: input for this session's agent, not the user's word. */
+export declare function PeerRow({ entry }: {
+    entry: PeerEntry;
+}): import("react").JSX.Element;
+/**
+ * What the agent was given of a monitor's output: the monitor, its lines (the command's output, so untrusted, shown
+ * as text) and how it ended.
+ */
+export declare function MonitorRow({ entry }: {
+    entry: MonitorEntry;
+}): import("react").JSX.Element;
 export declare function DiffBlock({ entry, renderDiff }: {
     entry: DiffEntry;
     renderDiff?: (patch: string) => React.ReactNode;

package/dist/features/memories/MemoriesPage.d.ts

@@ -0,0 +1 @@
+export default function MemoriesPage(): import("react").JSX.Element;

package/dist/features/memories/memoriesCommands.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../commands/registry';
+export declare const memoriesCommand: Command;
+export declare function registerMemoriesCommands(): void;

package/dist/features/memories/memoriesController.d.ts

@@ -0,0 +1,81 @@
+import type { ContextSources, MemoryRecord, MemoryRevision, MemoryScopeStatus } from '../../api/wire';
+export interface MemoriesView {
+    records: MemoryRecord[];
+    statuses: MemoryScopeStatus[];
+    projects: string[];
+    loaded: ReadonlySet<string>;
+    kept: ReadonlySet<string>;
+    revisions: MemoryRevision[] | null;
+    sources: ContextSources | null;
+    sourcesNote: string;
+    error: string;
+    busy: boolean;
+    version: number;
+}
+/** What a change says back: shown as a toast. */
+export interface Outcome {
+    ok: boolean;
+    message: string;
+}
+export declare class MemoriesController {
+    /** The session the context view describes, and whose project's memories open first. */
+    private readonly sessionId;
+    /** The server lists sessions' context sources (`context_sources`). */
+    private readonly contextSourcesServed;
+    private data;
+    private statuses;
+    private projectIds;
+    private readonly loadedProjects;
+    private readonly changed;
+    private revisionList;
+    private found;
+    private note;
+    private error;
+    private busy;
+    /** Answers to an earlier open are dropped. */
+    private generation;
+    private project;
+    /** Edits the server refused, by memory, reopened by the next edit. */
+    private readonly drafts;
+    private readonly listeners;
+    private snapshot;
+    constructor(
+    /** The session the context view describes, and whose project's memories open first. */
+    sessionId: string | null, 
+    /** The server lists sessions' context sources (`context_sources`). */
+    contextSourcesServed: () => boolean);
+    private view;
+    private render;
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => MemoriesView;
+    /** The project whose memories open first: the session's. */
+    get sessionProject(): string | null;
+    /** Read everything afresh: the session's context first, for its project. */
+    open(): Promise<void>;
+    private load;
+    /** The session's context sources; why there are none when there aren't. */
+    loadSources(): Promise<void>;
+    /** Read everything again, keeping the projects opened and the memories changed here. */
+    reload(): Promise<void>;
+    /** Another of the caller's projects, read when its scope is first chosen; what went wrong, or null. */
+    loadProject(project: string): Promise<string | null>;
+    history(record: MemoryRecord): Promise<Outcome | null>;
+    closeHistory(): void;
+    private replace;
+    forget(record: MemoryRecord): Promise<Outcome>;
+    restore(record: MemoryRecord): Promise<Outcome>;
+    /**
+     * What an edit starts from: the draft the server refused last time, else the memory as markdown, read afresh;
+     * with the record read, whose revision the save is made against.
+     */
+    startEdit(record: MemoryRecord): Promise<{
+        text: string;
+        current: MemoryRecord;
+        draft: boolean;
+    } | Outcome>;
+    /** Save an edit against the revision read; one refused is kept as the draft the next edit reopens. */
+    save(current: MemoryRecord, edited: string): Promise<Outcome>;
+    /** Throw away a refused edit. */
+    dropDraft(id: string): void;
+}
+export declare function useMemories(controller: MemoriesController): MemoriesView;

package/dist/features/workspace/claimsCommands.d.ts

@@ -0,0 +1,26 @@
+import type { Envelope } from '../../api/wire';
+import type { SessionController } from '../chat/session/SessionController';
+import type { Command, CommandContext } from '../commands/registry';
+type Toast = (message: string, tone?: 'info' | 'ok' | 'danger') => void;
+/** What a claim event or a contested session says, given the sessions the browser follows. */
+export interface ClaimsEnv {
+    /** A followed session, by id. */
+    get(id: string): Pick<SessionController, 'id' | 'store' | 'title' | 'notice'> | undefined;
+    /** The session on screen. */
+    shownId(): string | null;
+    toast: Toast;
+}
+/**
+ * A request opened, answered or ended, on session `id`'s stream: a toast, the session's title first when it is out
+ * of view. Both sides' streams carry it, so when the other side is on screen, that one says it in its own words.
+ */
+export declare function claimToast(env: ClaimsEnv, id: string, envelope: Envelope): void;
+/**
+ * Session `id`'s metadata changed: say once when a request it made could not be settled, which puts it in the inbox
+ * until the user's next message. The first read only takes stock.
+ */
+export declare function contestedCheck(env: ClaimsEnv, id: string): void;
+/** `/claims [release <path> | give <path> [session] | ask <path> [reason]]`. */
+export declare function runClaims(ctx: Pick<CommandContext, 'controller' | 'toast'>, args: string): Promise<void>;
+export declare const claimsCommand: Command;
+export {};

package/dist/features/workspace/collisionsWatcher.d.ts

@@ -12,6 +12,12 @@ export interface CollisionOptions {
     repoOf?: (controller: Watched) => string | null;
     /** A new hard collision, in words (the TUI flashes it); by default a warning in both sessions' transcripts. */
     warn?: (text: string, a: Watched | null, b: Watched | null) => void;
+    /**
+     * Whether a hard collision switches its sessions to asking. By default not once the server keeps file claims
+     * (`capabilities.peers`): it refuses a write to a file another session owns itself, and the agents settle it. A
+     * mode switched by an earlier collision still goes back.
+     */
+    gate?: () => boolean;
 }
 /** The repository a session works in, as the browser can tell: its workspace's top level. */
 export declare function defaultRepoOf(controller: Watched): string | null;
@@ -35,6 +41,7 @@ export declare class CollisionWatcher {
     private readonly listeners;
     private version;
     private readonly repoOf;
+    private readonly gates;
     private readonly warn;
     constructor(options?: CollisionOptions);
     subscribe: (listener: Listener) => (() => void);

package/dist/features/workspace/useSessionPageHooks.d.ts

@@ -1,6 +1,6 @@
 /**
  * Fill in the session page's hooks from the workspace feature: collisions
  * between the followed sessions (hold or leave a file on the approval card),
- * and the full diff viewer for `/diff` in the transcript.
+ * the file claims' toasts, and the full diff viewer for `/diff` in the transcript.
  */
 export declare function useSessionPageHooks(): void;