@ruimte/agents-react 0.0.0 → 0.7.0

package/dist/chat/logic/timeline.js

@@ -0,0 +1,339 @@
+import i18next from 'i18next';
+import { abortedByMachine } from '@ruimte/agent-contracts';
+import { formatElapsedShort } from '@ruimte/ui/format/duration';
+import { handbackReportOf } from './handback';
+import { toolEntry } from './tool-catalog';
+import { hasFileChanges, isFileChange } from './tools';
+/*
+ * A turn runs in two rhythms. The tool lines are a list and read as one when they sit tight
+ * against each other; prose and cards are blocks and need room around them. Where the two meet,
+ * the block gap marks the seam, so an answer never looks glued to the call above it.
+ */
+const BLOCK_KINDS = new Set(['assistant', 'report', 'thinking', 'changed-files', 'compaction']);
+export const isBlock = (row) => BLOCK_KINDS.has(row.kind);
+/* "Read 4 files", "Ran 2 commands", or "12 tool calls" when the run mixes kinds. */
+export const summarizeGroup = (tools) => {
+    const names = new Set(tools.map((tool) => tool.name));
+    const only = names.size === 1 ? tools[0].name : null;
+    if (only !== null && toolEntry(only)?.grouped === true) {
+        return i18next.t(`agent-chat:group.tools.${only}`, { count: tools.length });
+    }
+    /* A run that only touches files says so once, whether it took one tool or three, and counts the
+       files rather than the calls: three edits to one file are one file edited. */
+    if (tools.every((tool) => isFileChange(tool.name))) {
+        const paths = new Set(tools.map((tool) => tool.input?.file_path ?? tool.id));
+        return i18next.t('agent-chat:group.edited', { count: paths.size });
+    }
+    if (only !== null) {
+        return i18next.t('agent-chat:group.calls', { name: only, count: tools.length });
+    }
+    return i18next.t('agent-chat:group.toolCalls', { count: tools.length });
+};
+/*
+ * What a folded turn did, a sentence per kind of call in the order it first came: "Read 11 files",
+ * "Searched 2 patterns". Every file change reads as one sentence, and calls without a sentence of
+ * their own are counted together at the end.
+ */
+export const summarizeTurn = (tools) => {
+    // Keyed by the sentence, so its place is where the first call of that kind came.
+    const counts = new Map();
+    const edited = new Set();
+    let other = 0;
+    for (const tool of tools) {
+        if (isFileChange(tool.name)) {
+            edited.add(tool.input?.file_path ?? tool.id);
+            counts.set('agent-chat:group.edited', edited.size);
+        }
+        else if (toolEntry(tool.name)?.grouped === true) {
+            const key = `agent-chat:group.tools.${tool.name}`;
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+        }
+        else {
+            other += 1;
+        }
+    }
+    const parts = [...counts].map(([key, count]) => i18next.t(key, { count }));
+    if (other > 0) {
+        parts.push(i18next.t(parts.length === 0 ? 'agent-chat:group.toolCalls' : 'agent-chat:group.otherCalls', { count: other }));
+    }
+    return parts;
+};
+/*
+ * What a turn nobody asked for is about. The CLI wakes the agent when a background subagent settles
+ * and hands over its summary; without one all that is known is that the agent went on by itself.
+ */
+export const agentTurnLabel = (turn) => {
+    const about = (what) => (turn.label ? i18next.t('agent-chat:turn.about', { what, label: turn.label }) : what);
+    // A turn the machine opened with the results of tasks this chat gave; the label is their titles.
+    if (turn.taskIds !== undefined && turn.taskIds.length > 0) {
+        return about(i18next.t('agent-chat:turn.wokenByTask', { count: turn.taskIds.length }));
+    }
+    // A turn the machine opened over a message another node sent; the label names who sent it.
+    if (turn.messageFrom !== undefined && turn.messageFrom.length > 0) {
+        return about(i18next.t('agent-chat:turn.wokenByMessage', { count: turn.messageFrom.length }));
+    }
+    return turn.label ? i18next.t('agent-chat:turn.subagentFinished', { label: turn.label }) : i18next.t('agent-chat:turn.continued');
+};
+/* The items of the turn tell a turn a person stopped from one the machine ended after a restart. */
+export const turnLabel = (turn, items = []) => {
+    const duration = formatElapsedShort((turn.endedAt ?? turn.createdAt) - turn.createdAt);
+    switch (turn.state) {
+        case 'aborted':
+            return abortedByMachine(turn, items) ? i18next.t('agent-chat:turn.stopped', { duration }) : i18next.t('agent-chat:turn.youStopped', { duration });
+        case 'error':
+            return i18next.t('agent-chat:turn.failed', { duration });
+        default:
+            return i18next.t('agent-chat:turn.worked', { duration });
+    }
+};
+// A subagent's own work, and an agent it opened, belong to its row, not to the thread; an old record has no row for it.
+const parentOf = (item) => item.kind === 'tool' || item.kind === 'assistant' || item.kind === 'subagent' ? (item.parentToolUseId ?? null) : null;
+// Deeper than the CLI forwards any call; it also ends a chain of rows that would name each other.
+const MAX_NESTING = 8;
+const branchOf = (item, options, children, depth = 0) => {
+    const own = children.get(item.toolUseId) ?? [];
+    return {
+        id: item.id,
+        item,
+        children: own.filter((child) => child.kind !== 'subagent'),
+        nested: depth >= MAX_NESTING
+            ? []
+            : own.filter((child) => child.kind === 'subagent').map((child) => branchOf(child, options, children, depth + 1)),
+        expanded: options.expandedSubagents.has(item.id)
+    };
+};
+/* The branch a subagent's row sits in, its own or one it hangs under, anywhere in the thread's rows. */
+export const findSubagentBranch = (rows, toolUseId) => {
+    const search = (branch) => {
+        if (branch.item.toolUseId === toolUseId) {
+            return branch;
+        }
+        for (const child of branch.nested) {
+            const found = search(child);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    };
+    for (let index = 0; index < rows.length; index++) {
+        const row = rows[index];
+        const branch = row.kind === 'subagent' ? search(row) : null;
+        if (branch) {
+            return { index, branch };
+        }
+    }
+    return null;
+};
+/* What each subagent did, keyed by the call that spawned it, in the order it happened. */
+const groupChildren = (items) => {
+    const children = new Map();
+    for (const item of items) {
+        const parent = parentOf(item);
+        if (parent === null) {
+            continue;
+        }
+        const bucket = children.get(parent);
+        if (bucket) {
+            bucket.push(item);
+        }
+        else {
+            children.set(parent, [item]);
+        }
+    }
+    return children;
+};
+const flushTools = (buffer, rows, options) => {
+    if (buffer.length === 0) {
+        return;
+    }
+    const tools = buffer.splice(0);
+    const live = tools.filter((tool) => tool.state === 'running');
+    const settled = tools.filter((tool) => tool.state !== 'running');
+    if (settled.length === 1) {
+        rows.push({ kind: 'work', id: settled[0].id, tool: settled[0] });
+    }
+    else if (settled.length > 1) {
+        const id = `group-${settled[0].id}`;
+        const expanded = options.expandedGroups.has(id);
+        rows.push({ kind: 'work-group', id, tools: settled, summary: summarizeGroup(settled), expanded });
+        if (expanded) {
+            for (const tool of settled) {
+                rows.push({ kind: 'work', id: tool.id, tool });
+            }
+        }
+    }
+    for (const tool of live) {
+        rows.push({ kind: 'work-live', id: tool.id, tool });
+    }
+};
+/* Rows for a run of items, in order, with tool runs folded and a subagent's work under its own row. */
+const rowsForItems = (items, options, children) => {
+    const rows = [];
+    const tools = [];
+    for (const item of items) {
+        if (parentOf(item) !== null) {
+            continue;
+        }
+        const report = handbackReportOf(item);
+        if (item.kind === 'tool' && item.workflow !== undefined) {
+            flushTools(tools, rows, options);
+            rows.push({ kind: 'workflow', id: item.id, tool: item, workflow: item.workflow });
+            continue;
+        }
+        if (item.kind === 'tool' && report === null) {
+            tools.push(item);
+            continue;
+        }
+        if (report !== null) {
+            flushTools(tools, rows, options);
+            rows.push({ kind: 'report', id: item.id, text: report });
+            continue;
+        }
+        flushTools(tools, rows, options);
+        switch (item.kind) {
+            case 'subagent':
+                rows.push({ kind: 'subagent', ...branchOf(item, options, children) });
+                break;
+            case 'user':
+                rows.push({ kind: 'user', id: item.id, item });
+                break;
+            case 'assistant':
+                if (item.text !== '' || item.streaming) {
+                    rows.push({ kind: 'assistant', id: item.id, item });
+                }
+                break;
+            case 'thinking':
+                rows.push({ kind: 'thinking', id: item.id, item });
+                break;
+            case 'approval':
+                // A pending one sits on the composer; only its outcome belongs in the transcript.
+                if (item.decision !== 'pending') {
+                    rows.push({ kind: 'approval', id: item.id, item });
+                }
+                break;
+            case 'question':
+                if (item.state !== 'pending') {
+                    rows.push({ kind: 'question', id: item.id, item });
+                }
+                break;
+            case 'note':
+                rows.push({ kind: 'note', id: item.id, level: item.level, text: item.text, ...(item.from === undefined ? {} : { from: item.from }) });
+                break;
+            case 'compaction':
+                rows.push({ kind: 'compaction', id: item.id, preTokens: item.preTokens });
+                break;
+            case 'turn':
+                break;
+        }
+    }
+    flushTools(tools, rows, options);
+    return rows;
+};
+/* The card of a settled turn: the checkpoint diff when the host took one, else what the tool calls carry. */
+const changedFilesRow = (turn, items) => {
+    const edits = items.filter((item) => item.kind === 'tool' && item.state === 'done' && isFileChange(item.name) && hasFileChanges(item));
+    const diff = turn.checkpointDiff ?? null;
+    const empty = diff === null ? edits.length === 0 : diff.files.length === 0;
+    if (empty) {
+        return null;
+    }
+    return { kind: 'changed-files', id: `files-${turn.id}`, turnId: turn.id, tools: edits, diff, checkpoint: turn.checkpoint !== undefined };
+};
+const lastAssistantRow = (rows) => {
+    for (let i = rows.length - 1; i >= 0; i--) {
+        const row = rows[i];
+        if (row.kind === 'assistant') {
+            return row;
+        }
+        if (row.kind !== 'note') {
+            return null;
+        }
+    }
+    return null;
+};
+/* The whole thread as rows; items without a turn (older records) are shown as they are. */
+export const deriveTimelineRows = (items, options) => {
+    const rows = [];
+    const children = groupChildren(items);
+    // Items are grouped by turn, in order of first appearance; runs of turnless items keep their place.
+    const chunks = [];
+    const byTurn = new Map();
+    for (const item of items) {
+        if (item.turnId === null) {
+            const last = chunks[chunks.length - 1];
+            if (last && last.turnId === null) {
+                last.items.push(item);
+            }
+            else {
+                chunks.push({ turnId: null, items: [item] });
+            }
+            continue;
+        }
+        let bucket = byTurn.get(item.turnId);
+        if (!bucket) {
+            bucket = [];
+            byTurn.set(item.turnId, bucket);
+            chunks.push({ turnId: item.turnId, items: bucket });
+        }
+        bucket.push(item);
+    }
+    for (const chunk of chunks) {
+        if (chunk.turnId === null) {
+            rows.push(...rowsForItems(chunk.items, options, children));
+            continue;
+        }
+        const turnId = chunk.turnId;
+        const turn = chunk.items.find((item) => item.kind === 'turn');
+        const user = chunk.items.filter((item) => item.kind === 'user');
+        const rest = chunk.items.filter((item) => item.kind !== 'user' && item.kind !== 'turn');
+        if (turn?.origin === 'agent') {
+            // The agent started this one itself, so there is no message of the person to show above it.
+            rows.push({ kind: 'turn-start', id: `start-${turnId}`, turn, label: agentTurnLabel(turn) });
+        }
+        rows.push(...rowsForItems(user, options, children));
+        const active = turnId === options.activeTurnId || turn?.state === 'running';
+        const work = rowsForItems(rest, options, children);
+        if (!turn || active) {
+            rows.push(...work);
+            if (active) {
+                rows.push({ kind: 'working', id: `working-${turnId}`, startedAt: turn?.createdAt ?? Date.now() });
+            }
+            continue;
+        }
+        // The closing answer stays visible; everything before it folds behind the label.
+        const finalAssistant = lastAssistantRow(work);
+        const before = finalAssistant ? work.slice(0, work.indexOf(finalAssistant)) : work;
+        // A workflow runs on past the turn that launched it, so its row stays in sight until it ends.
+        const standing = before.filter((row) => row.kind === 'workflow' && row.tool.state === 'running');
+        const folded = before.filter((row) => !standing.includes(row));
+        const expanded = options.expandedTurns.has(turnId);
+        if (folded.length > 0) {
+            const tools = rest.filter((item) => item.kind === 'tool' && parentOf(item) === null && handbackReportOf(item) === null);
+            rows.push({
+                kind: 'turn-fold',
+                id: `fold-${turnId}`,
+                turn,
+                label: turnLabel(turn, chunk.items),
+                work: summarizeTurn(tools),
+                hiddenCount: folded.length,
+                expanded
+            });
+            if (expanded) {
+                rows.push(...folded);
+            }
+        }
+        rows.push(...standing);
+        const changed = changedFilesRow(turn, rest);
+        if (changed) {
+            rows.push(changed);
+        }
+        if (finalAssistant) {
+            rows.push(finalAssistant);
+        }
+        if (options.forkedTurns?.has(turnId) === true) {
+            rows.push({ kind: 'forks', id: `forks-${turnId}`, turnId });
+        }
+    }
+    return rows;
+};

package/dist/chat/logic/tool-catalog.d.ts

@@ -0,0 +1,10 @@
+import { type LucideIcon } from 'lucide-react';
+export interface ToolEntry {
+    icon: LucideIcon;
+    summary: readonly string[];
+    grouped: boolean;
+    changesFiles: boolean;
+    readsImage: boolean;
+}
+export declare const TOOL_CATALOG: Record<string, ToolEntry>;
+export declare const toolEntry: (name: string) => ToolEntry | undefined;

package/dist/chat/logic/tool-catalog.js

@@ -0,0 +1,40 @@
+import { Bot, Eye, FolderSearch, Globe, ListTodo, Search, SquarePen, Terminal, Workflow, Zap } from 'lucide-react';
+const entry = (icon, summary, rest = {}) => ({
+    icon,
+    summary,
+    grouped: true,
+    changesFiles: false,
+    readsImage: false,
+    ...rest
+});
+/*
+ * The icon, the summary line, the group sentence and the file-changing flag of every tool the thread
+ * has a word for, in one table, because they used to sit in four and a name added to one of them was
+ * missing from the rest. A name that is not here still draws, reads and groups; it falls back to the
+ * wrench and to the first string of its input.
+ */
+export const TOOL_CATALOG = {
+    Read: entry(Eye, ['file_path'], { readsImage: true }),
+    // Only `readImagePath` ever had this one, which is why it has no sentence of its own yet.
+    NotebookRead: entry(Eye, ['file_path', 'notebook_path'], { grouped: false, readsImage: true }),
+    // These three read as "Edited 3 files" through `changesFiles`, so they carry no copy of that sentence.
+    Edit: entry(SquarePen, ['file_path'], { grouped: false, changesFiles: true }),
+    Write: entry(SquarePen, ['file_path'], { changesFiles: true }),
+    MultiEdit: entry(SquarePen, ['file_path'], { grouped: false, changesFiles: true }),
+    NotebookEdit: entry(SquarePen, ['file_path', 'notebook_path']),
+    // Codex reports a patch as the paths it touches; its own input carries no path of its own.
+    ApplyPatch: entry(SquarePen, ['summary'], { grouped: false, changesFiles: true }),
+    Bash: entry(Terminal, ['description', 'command']),
+    Grep: entry(Search, ['pattern']),
+    Glob: entry(FolderSearch, ['pattern']),
+    WebFetch: entry(Globe, ['url', 'query']),
+    WebSearch: entry(Globe, ['url', 'query']),
+    Task: entry(Bot, ['description']),
+    Agent: entry(Bot, ['description']),
+    Skill: entry(Zap, ['skill']),
+    // A plan is a list of objects, so there is no line to lift out of it.
+    TodoWrite: entry(ListTodo, []),
+    // Its input is the whole script; the line takes what the CLI says the workflow is about instead.
+    Workflow: entry(Workflow, [], { grouped: false })
+};
+export const toolEntry = (name) => TOOL_CATALOG[name];

package/dist/chat/logic/tools.d.ts

@@ -0,0 +1,15 @@
+import type { ChatFileChange, ChatToolItem } from '@ruimte/agent-contracts';
+export interface FileChange {
+    path: string;
+    before: string;
+    after: string;
+}
+export declare const toolSummary: (name: string, input: unknown) => string;
+export declare const readImagePath: (name: string, input: unknown) => string | null;
+export declare const fileChanges: (name: string, input: unknown) => FileChange[];
+export declare const isFileChange: (name: string) => boolean;
+export declare const unifiedChanges: (tool: ChatToolItem) => ChatFileChange[];
+export declare const approvalChanges: (input: unknown) => ChatFileChange[];
+export declare const hasFileChanges: (tool: ChatToolItem) => boolean;
+export declare const toolStartedAt: (tool: ChatToolItem) => number;
+export declare const liveOutput: (tool: ChatToolItem) => string | null;

package/dist/chat/logic/tools.js

@@ -0,0 +1,79 @@
+import { isRecord } from './json';
+import { toolEntry } from './tool-catalog';
+const str = (value) => (typeof value === 'string' ? value : null);
+/* The one line that says what a tool call is about: the command, the file, the pattern. */
+export const toolSummary = (name, input) => {
+    if (!isRecord(input)) {
+        return '';
+    }
+    const known = toolEntry(name);
+    if (known === undefined) {
+        // A tool nobody wrote down, an MCP one above all, gets its best guess from the first string it was given.
+        const first = Object.values(input).find((value) => typeof value === 'string');
+        return typeof first === 'string' ? first : '';
+    }
+    for (const key of known.summary) {
+        const value = str(input[key]);
+        if (value !== null) {
+            return value;
+        }
+    }
+    return '';
+};
+// What `GET /fs/file` will serve; a path with another suffix is not worth asking the host about.
+const IMAGE_SUFFIXES = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'];
+/* The image file a tool call looked at, so the row can draw it; null for every other call. */
+export const readImagePath = (name, input) => {
+    if (toolEntry(name)?.readsImage !== true) {
+        return null;
+    }
+    const path = isRecord(input) ? str(input.file_path) : null;
+    if (path === null) {
+        return null;
+    }
+    const lowered = path.toLowerCase();
+    return IMAGE_SUFFIXES.some((suffix) => lowered.endsWith(suffix)) ? path : null;
+};
+/* The before and after text of a file-changing tool call, so the thread can show it as a diff. */
+export const fileChanges = (name, input) => {
+    if (!isRecord(input)) {
+        return [];
+    }
+    const path = str(input.file_path) ?? '';
+    if (name === 'Edit') {
+        return [{ path, before: str(input.old_string) ?? '', after: str(input.new_string) ?? '' }];
+    }
+    if (name === 'Write') {
+        return [{ path, before: '', after: str(input.content) ?? '' }];
+    }
+    if (name === 'MultiEdit' && Array.isArray(input.edits)) {
+        return input.edits.filter(isRecord).map((edit) => ({ path, before: str(edit.old_string) ?? '', after: str(edit.new_string) ?? '' }));
+    }
+    return [];
+};
+export const isFileChange = (name) => toolEntry(name)?.changesFiles === true;
+/* The unified diffs a provider put next to a tool call; empty for one that reports before and after. */
+export const unifiedChanges = (tool) => (tool.changes ?? []).filter((change) => change.diff !== '');
+/* The same, for the copy an approval carries so the person can read what they are approving. */
+export const approvalChanges = (input) => {
+    const changes = isRecord(input) ? input.changes : null;
+    if (!Array.isArray(changes)) {
+        return [];
+    }
+    return changes.filter((change) => isRecord(change) && typeof change.path === 'string' && typeof change.diff === 'string' && change.diff !== '');
+};
+/* Whether a settled call is worth a row in the turn's changed files card. */
+export const hasFileChanges = (tool) => unifiedChanges(tool).length > 0 || fileChanges(tool.name, tool.input).length > 0;
+/* When a running call started: what the CLI reported, or the moment the call appeared. */
+export const toolStartedAt = (tool) => tool.progress?.startedAt ?? tool.createdAt;
+// Partial output is a tail: what the command says now matters more than what it said first.
+const LIVE_OUTPUT_LINES = 12;
+/* The last lines of a running call's output, or null when the provider streams none. */
+export const liveOutput = (tool) => {
+    const output = tool.progress?.output;
+    if (!output) {
+        return null;
+    }
+    const lines = output.replace(/\n$/, '').split('\n');
+    return lines.slice(-LIVE_OUTPUT_LINES).join('\n');
+};

package/dist/chat/logic/workflow.d.ts

@@ -0,0 +1,14 @@
+import type { ChatSubagentStatus, ChatWorkflow, ChatWorkflowAgent } from '@ruimte/agent-contracts';
+export type WorkflowAgentState = ChatSubagentStatus | 'waiting' | 'stopped';
+export interface WorkflowAgentView {
+    agent: ChatWorkflowAgent;
+    state: WorkflowAgentState;
+}
+export interface WorkflowPhaseView {
+    key: string;
+    title: string | null;
+    agents: WorkflowAgentView[];
+}
+export declare const workflowAgentState: (agent: ChatWorkflowAgent, workflowRunning: boolean) => WorkflowAgentState;
+export declare const workflowPhases: (workflow: ChatWorkflow, workflowRunning: boolean) => WorkflowPhaseView[];
+export declare const workflowAgentTime: (view: WorkflowAgentView) => string | null;

package/dist/chat/logic/workflow.js

@@ -0,0 +1,47 @@
+import i18next from 'i18next';
+import { formatElapsedShort } from '@ruimte/ui/format/duration';
+export const workflowAgentState = (agent, workflowRunning) => {
+    if (agent.status !== 'running') {
+        return agent.status;
+    }
+    if (!workflowRunning) {
+        return 'stopped';
+    }
+    return agent.startedAt === null ? 'waiting' : 'running';
+};
+/*
+ * The phases in the order the script announced them, each with the agents it started in it. A phase
+ * announced ahead of its agents is there without any, and agents of no known phase come first, untitled.
+ */
+export const workflowPhases = (workflow, workflowRunning) => {
+    const known = new Map(workflow.phases.map((phase) => [phase.index, phase]));
+    const loose = [];
+    const byPhase = new Map();
+    for (const agent of workflow.agents) {
+        const view = { agent, state: workflowAgentState(agent, workflowRunning) };
+        if (agent.phaseIndex === null || !known.has(agent.phaseIndex)) {
+            loose.push(view);
+            continue;
+        }
+        byPhase.set(agent.phaseIndex, [...(byPhase.get(agent.phaseIndex) ?? []), view]);
+    }
+    const phases = workflow.phases.map((phase) => ({ key: `phase-${phase.index}`, title: phase.title, agents: byPhase.get(phase.index) ?? [] }));
+    return loose.length > 0 ? [{ key: 'loose', title: null, agents: loose }, ...phases] : phases;
+};
+/* What the line of an agent that is not at work says about its time; one at work counts on by itself. */
+export const workflowAgentTime = (view) => {
+    const duration = view.agent.durationMs === null ? null : formatElapsedShort(view.agent.durationMs);
+    switch (view.state) {
+        case 'running':
+            return null;
+        case 'waiting':
+            return i18next.t('agent-chat:rows.workflow.waiting');
+        case 'stopped':
+            return i18next.t('agent-chat:rows.workflow.stopped');
+        case 'done':
+        case 'failed':
+            return duration === null
+                ? i18next.t(`agent-chat:common.status.${view.state}`)
+                : i18next.t(`agent-chat:rows.subagent.${view.state}In`, { duration });
+    }
+};

package/dist/chat/mentions.d.ts

@@ -0,0 +1,46 @@
+export declare const MENTION_DRAG_TYPE = "application/x-ruimte-mention";
+export interface MentionQuery {
+    start: number;
+    query: string;
+}
+export type ChipSegment = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'mention';
+    path: string;
+} | {
+    kind: 'skill';
+    name: string;
+};
+export declare const findMentionQuery: (text: string, caret: number) => MentionQuery | null;
+export declare const findSkillQuery: (text: string, caret: number) => MentionQuery | null;
+export declare const insertToken: (text: string, query: MentionQuery, sigil: string, value: string) => {
+    text: string;
+    caret: number;
+};
+export declare const dropQuery: (text: string, query: MentionQuery) => {
+    text: string;
+    caret: number;
+};
+export declare const insertMention: (text: string, query: MentionQuery, path: string) => {
+    text: string;
+    caret: number;
+};
+export declare const insertSkill: (text: string, query: MentionQuery, name: string) => {
+    text: string;
+    caret: number;
+};
+export declare const presentMentions: (text: string, chosen: string[]) => string[];
+export declare const presentSkills: (text: string, chosen: string[]) => string[];
+export declare const chipText: (segment: ChipSegment) => string;
+export interface TextRange {
+    from: number;
+    to: number;
+}
+export interface ChipRange extends TextRange {
+    kind: 'mention' | 'skill';
+    value: string;
+}
+export declare const chipRanges: (text: string, mentions: string[], skills?: string[], excluded?: readonly TextRange[]) => ChipRange[];
+export declare const tokenizeChips: (text: string, mentions: string[], skills?: string[]) => ChipSegment[];