@kortix/ui 0.0.0-stage → 0.14.4

package/dist/internal/lib/utils/kortix-system-tags.js

@@ -0,0 +1,222 @@
+import { indexOfIgnoreCase, removeSpans, tagBlocks } from '../../../_vendor/kortix-shared.js';
+/**
+ * Kortix System XML — utilities for handling <kortix_system> tags.
+ *
+ * Backend plugins wrap internal content (session context, memory, orchestrator
+ * state, PTY output, etc.) in <kortix_system type="..." source="..."> tags.
+ *
+ * - stripKortixSystemTags: removes ALL tags before markdown rendering
+ * - extractSessionReport: parses session-report tags into structured data
+ *
+ * Nothing here runs a regex over the message. The regexes these functions used
+ * were quadratic or cubic in the text — extracting system messages from 60k
+ * characters took 53 s — and every viewer of a session parses every user
+ * message in it. The scanners are in `@kortix/shared/tag-blocks`.
+ */
+const OPEN = '<kortix_system';
+const CLOSE = '</kortix_system>';
+/** Removes every `<kortix_system …>…</kortix_system>` block, in any ASCII case. */
+export function stripKortixSystemTags(text) {
+    if (!text)
+        return '';
+    return removeSpans(text, tagBlocks(text, 'kortix_system', { attributes: 'any', ignoreCase: true })).trim();
+}
+export function extractSessionReport(text) {
+    if (!text)
+        return null;
+    const xml = sessionReportXml(text);
+    if (xml === null)
+        return null;
+    const get = (tag) => tagBlocks(xml, tag, { limit: 1 })[0]?.body.trim() || '';
+    return {
+        sessionId: get('session-id'),
+        status: get('status') === 'FAILED' ? 'FAILED' : 'COMPLETE',
+        project: get('project'),
+        prompt: get('prompt'),
+        result: get('result'),
+    };
+}
+/**
+ * The text between `<session-report>` and `</session-report>` after the first
+ * `<kortix_system …>` tag that holds `type="session-report"`, with a closing
+ * `</kortix_system>` after it — what
+ * `/<kortix_system[^>]*type="session-report"[^>]*>[\s\S]*?<session-report>([\s\S]*?)<\/session-report>[\s\S]*?<\/kortix_system>/i`
+ * captured. That regex was cubic: 7.6 s at 60k characters.
+ */
+function sessionReportXml(text) {
+    const marker = 'type="session-report"';
+    let from = 0;
+    // The first marker at or after the last position searched from; -2 until searched.
+    let markerAt = -2;
+    for (;;) {
+        const open = indexOfIgnoreCase(text, OPEN, from);
+        if (open === -1)
+            return null;
+        const attrs = open + OPEN.length;
+        const gt = text.indexOf('>', attrs);
+        if (gt === -1)
+            return null;
+        if (markerAt < attrs)
+            markerAt = indexOfIgnoreCase(text, marker, attrs);
+        if (markerAt === -1)
+            return null;
+        // The marker lies past this tag. Every opener before `gt` shares this tag's
+        // attributes, so none of them holds the marker either.
+        if (markerAt > gt) {
+            from = gt;
+            continue;
+        }
+        // Each search below failing means no later opener can succeed: its search starts later still.
+        const start = indexOfIgnoreCase(text, '<session-report>', gt + 1);
+        if (start === -1)
+            return null;
+        const stop = indexOfIgnoreCase(text, '</session-report>', start + 16);
+        if (stop === -1)
+            return null;
+        if (indexOfIgnoreCase(text, CLOSE, stop + 17) === -1)
+            return null;
+        return text.slice(start + 16, stop);
+    }
+}
+/**
+ * Check if a user message text is purely a kortix_system message
+ * (no visible user content outside the tags).
+ */
+export function isKortixSystemOnly(text) {
+    if (!text)
+        return false;
+    return stripKortixSystemTags(text).length === 0;
+}
+/**
+ * Each `<kortix_system …>…</kortix_system>` whose opening tag holds `type="…"`
+ * and, after it, `source="…"` — what
+ * `/<kortix_system[^>]*?\btype="([^"]*)"[^>]*?\bsource="([^"]*)"[^>]*>([\s\S]*?)<\/kortix_system>/gi`
+ * matched, in order. That regex was cubic: 53 s at 60k characters.
+ *
+ * One intended difference: a `>` ends the opening tag even inside a quoted
+ * value, as it does for `stripKortixSystemTags`. The regex read on through it.
+ * The runtime never writes `>` into a type or a source.
+ */
+export function kortixSystemElements(text) {
+    const out = [];
+    if (!text)
+        return out;
+    let from = 0;
+    for (;;) {
+        const open = indexOfIgnoreCase(text, OPEN, from);
+        if (open === -1)
+            return out;
+        const attrs = open + OPEN.length;
+        const gt = text.indexOf('>', attrs);
+        if (gt === -1)
+            return out;
+        const found = typeAndSource(text.slice(attrs, gt));
+        // Every opener before `gt` lies inside these attributes, so none of them has a match either.
+        if (!found) {
+            from = gt;
+            continue;
+        }
+        const close = indexOfIgnoreCase(text, CLOSE, gt + 1);
+        if (close === -1)
+            return out;
+        out.push({ ...found, body: text.slice(gt + 1, close) });
+        from = close + CLOSE.length;
+    }
+}
+/**
+ * The value of the first `type="…"` in a tag's attributes and of the first
+ * `source="…"` after that value. Both names match whole words in any ASCII case.
+ * Only the first `type` counts: a later one has no `source` after it either.
+ */
+function typeAndSource(attrs) {
+    // Index 0 follows the tag name directly, so a word cannot start there.
+    const type = attributeAt(attrs, 'type="', 1);
+    if (type === -1)
+        return null;
+    const typeEnd = attrs.indexOf('"', type + 6);
+    if (typeEnd === -1)
+        return null;
+    const source = attributeAt(attrs, 'source="', typeEnd + 1);
+    if (source === -1)
+        return null;
+    const sourceEnd = attrs.indexOf('"', source + 8);
+    if (sourceEnd === -1)
+        return null;
+    return { type: attrs.slice(type + 6, typeEnd), source: attrs.slice(source + 8, sourceEnd) };
+}
+/** The first `name` at or after `from` that starts a word, ignoring ASCII case; -1 when none does. */
+function attributeAt(attrs, name, from) {
+    for (let at = indexOfIgnoreCase(attrs, name, from); at !== -1; at = indexOfIgnoreCase(attrs, name, at + 1)) {
+        if (!/\w/.test(attrs[at - 1]))
+            return at;
+    }
+    return -1;
+}
+/**
+ * Extract structured info from kortix_system tags for inline UI rendering.
+ * Returns an array of parsed system messages found in the text.
+ */
+export function extractKortixSystemMessages(text, tI18nComplete) {
+    if (!text)
+        return [];
+    const results = [];
+    for (const element of kortixSystemElements(text)) {
+        const { type, source } = element;
+        const body = element.body.trim();
+        // Skip types that are already rendered elsewhere or are purely hidden context.
+        if (type === 'session-report' ||
+            type.startsWith('pty-') ||
+            type === 'project-status' ||
+            type === 'project-context' ||
+            type === 'workspace-context' ||
+            type === 'session-context' ||
+            type === 'memory-context')
+            continue;
+        const { label, detail } = describeSystemMessage(type, source, body, tI18nComplete);
+        results.push({ type, source, label, detail });
+    }
+    return results;
+}
+function describeSystemMessage(type, source, body, tI18nComplete) {
+    // Goal / Ralph continuation
+    if (type === 'goal-continue' || type === 'ralph-continue') {
+        const iterMatch = body.match(/\[(?:GOAL|RALPH)\s*-\s*ITERATION\s+(\d+)\/(\d+)\]/i);
+        if (iterMatch) {
+            return {
+                label: tI18nComplete.raw('textcdbf6975e8a3'),
+                detail: tI18nComplete('text3f63de86866c', {
+                    current: iterMatch[1],
+                    total: iterMatch[2],
+                }),
+            };
+        }
+        if (body.includes('COMPLETION REJECTED')) {
+            return {
+                label: tI18nComplete.raw('textcdbf6975e8a3'),
+                detail: tI18nComplete.raw('textf6b6716f736b'),
+            };
+        }
+        return {
+            label: tI18nComplete.raw('textcdbf6975e8a3'),
+            detail: tI18nComplete.raw('text6e9f041725ac'),
+        };
+    }
+    // Task-related
+    if (type === 'tasks') {
+        return {
+            label: tI18nComplete.raw('textb3a60e61a523'),
+            detail: tI18nComplete.raw('text75c75efe327a'),
+        };
+    }
+    // Project status injection
+    if (type === 'project-status') {
+        return { label: tI18nComplete.raw('text985959785319'), detail: 'status' };
+    }
+    // Rules / instructions
+    if (type === 'rules' || type === 'instruction') {
+        return { label: tI18nComplete.raw('text6725e7bbcd28'), detail: source.replace(/^kortix-/, '') };
+    }
+    // Fallback
+    const shortSource = source.replace(/^kortix-/, '');
+    return { label: type.replace(/-/g, ' '), detail: shortSource !== type ? shortSource : undefined };
+}

package/dist/internal/lib/utils/kortix-tool-output.d.ts

@@ -0,0 +1,58 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * Shared parsing utilities for Kortix Orchestrator tool outputs.
+ * These are used by both inline renderers and side panel tool views.
+ */
+export interface ProjectEntry {
+    name: string;
+    path: string;
+    sessions: number;
+    description: string;
+}
+export declare function parseProjectListOutput(output: string): ProjectEntry[];
+export interface ProjectGetData {
+    name: string;
+    path: string;
+    description: string | null;
+    id: string;
+    sessions: Array<{
+        status: string;
+        count: number;
+    }>;
+    contextExists: boolean;
+    contextPath: string;
+}
+export declare function parseProjectGetOutput(output: string): ProjectGetData | null;
+export interface ProjectSelectData {
+    name: string;
+    path: string;
+    success: boolean;
+}
+export declare function parseProjectSelectOutput(output: string): ProjectSelectData | null;
+export interface ProjectCreateData {
+    name: string;
+    path: string;
+    id: string;
+    success: boolean;
+}
+export declare function parseProjectCreateOutput(output: string): ProjectCreateData | null;
+export interface ConnectorEntry {
+    name: string;
+    description: string;
+    source: string;
+}
+export declare function parseConnectorListOutput(output: string): ConnectorEntry[];
+export interface ConnectorGetData {
+    name: string;
+    description: string;
+    source: string;
+    env?: string;
+    notes?: string;
+}
+export declare function parseConnectorGetOutput(output: string): ConnectorGetData | null;
+export interface ConnectorSetupData {
+    count: number;
+    connectors: string[];
+    success: boolean;
+}
+export declare function parseConnectorSetupOutput(output: string): ConnectorSetupData | null;

package/dist/internal/lib/utils/kortix-tool-output.js

@@ -0,0 +1,148 @@
+/**
+ * Shared parsing utilities for Kortix Orchestrator tool outputs.
+ * These are used by both inline renderers and side panel tool views.
+ */
+export function parseProjectListOutput(output) {
+    if (!output || typeof output !== 'string')
+        return [];
+    const projects = [];
+    // Try 4-column format first: | **name** | `/path` | sessions | description |
+    const fourColRe = /^\|\s*\*\*([^*]+)\*\*\s*\|\s*`([^`]+)`\s*\|\s*(\d+)\s*\|\s*([^|]*?)\s*\|$/gm;
+    let m;
+    while ((m = fourColRe.exec(output)) !== null) {
+        projects.push({
+            name: m[1].trim(),
+            path: m[2].trim(),
+            sessions: parseInt(m[3], 10) || 0,
+            description: m[4].trim() || '—',
+        });
+    }
+    if (projects.length > 0)
+        return projects;
+    // Fallback: 3-column format: | **name** | `/path` | description |
+    const threeColRe = /^\|\s*\*\*([^*]+)\*\*\s*\|\s*`([^`]+)`\s*\|\s*([^|]*?)\s*\|$/gm;
+    while ((m = threeColRe.exec(output)) !== null) {
+        projects.push({
+            name: m[1].trim(),
+            path: m[2].trim(),
+            sessions: 0,
+            description: m[3].trim() || '—',
+        });
+    }
+    return projects;
+}
+export function parseProjectGetOutput(output) {
+    if (!output || typeof output !== 'string')
+        return null;
+    const nameMatch = output.match(/^##\s+(.+)$/m);
+    const pathMatch = output.match(/\*\*Path:\*\*\s+`([^`]+)`/);
+    const descMatch = output.match(/\*\*Description:\*\*\s+(.+)$/m);
+    const idMatch = output.match(/\*\*ID:\*\*\s+`([^`]+)`/);
+    const contextMatch = output.match(/\*\*Context:\*\*\s+`([^`]+)`\s*([✓✓])?/);
+    const contextExists = !!contextMatch?.[2];
+    const contextPath = contextMatch?.[1] || '';
+    // Sessions section
+    const sessions = [];
+    const bulletRe = /^-\s+(running|completed|failed|pending):\s+(\d+)/gm;
+    let sm;
+    while ((sm = bulletRe.exec(output)) !== null) {
+        sessions.push({
+            status: sm[1],
+            count: parseInt(sm[2], 10) || 0,
+        });
+    }
+    return {
+        name: nameMatch?.[1] || 'Unknown Project',
+        path: pathMatch?.[1] || '',
+        description: descMatch?.[1] || null,
+        id: idMatch?.[1] || '',
+        sessions,
+        contextExists,
+        contextPath,
+    };
+}
+export function parseProjectSelectOutput(output) {
+    if (!output || typeof output !== 'string')
+        return null;
+    const nameMatch = output.match(/Project\s+\*\*([^*]+)\*\*\s+selected/i);
+    const pathMatch = output.match(/Path:\s+`([^`]+)`/);
+    if (!nameMatch)
+        return null;
+    return {
+        name: nameMatch[1],
+        path: pathMatch?.[1] || '',
+        success: !!nameMatch && output.includes('selected'),
+    };
+}
+export function parseProjectCreateOutput(output) {
+    if (!output || typeof output !== 'string')
+        return null;
+    const nameMatch = output.match(/Project\s+\*\*([^*]+)\*\*\s+at/i);
+    const pathMatch = output.match(/at\s+`([^`]+)`/);
+    const idMatch = output.match(/\((proj-[^)]+)\)/);
+    if (!nameMatch)
+        return null;
+    return {
+        name: nameMatch[1],
+        path: pathMatch?.[1] || '',
+        id: idMatch?.[1] || '',
+        success: !!nameMatch && !output.toLowerCase().includes('failed'),
+    };
+}
+export function parseConnectorListOutput(output) {
+    if (!output || typeof output !== 'string')
+        return [];
+    const connectors = [];
+    // Parse markdown table: | Name | Description | Source |
+    const lineRe = /^\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|\s*([^|]*?)\s*\|$/gm;
+    let m;
+    while ((m = lineRe.exec(output)) !== null) {
+        const name = m[1].trim();
+        // Skip header row and separator row
+        if (name === 'Name' || name.startsWith('---') || name.startsWith('–'))
+            continue;
+        connectors.push({
+            name,
+            description: m[2].trim(),
+            source: m[3].trim(),
+        });
+    }
+    return connectors;
+}
+export function parseConnectorGetOutput(output) {
+    if (!output || typeof output !== 'string')
+        return null;
+    const nameMatch = output.match(/^name:\s*(.+)$/m);
+    const descriptionMatch = output.match(/^description:\s*(.+)$/m);
+    const sourceMatch = output.match(/^source:\s*(.+)$/m);
+    const envMatch = output.match(/^env:\s*(.+)$/m);
+    const notesMatch = output.match(/^notes:\s*\n([\s\S]*)$/m);
+    if (!nameMatch)
+        return null;
+    return {
+        name: nameMatch[1].trim(),
+        description: descriptionMatch?.[1].trim() || '',
+        source: sourceMatch?.[1].trim() || 'unknown',
+        env: envMatch?.[1].trim(),
+        notes: notesMatch?.[1].trim(),
+    };
+}
+export function parseConnectorSetupOutput(output) {
+    if (!output || typeof output !== 'string')
+        return null;
+    // Match "Created/updated X connectors:" or legacy "Scaffolded X connectors"
+    const countMatch = output.match(/(?:Created\/updated|Scaffolded)\s+(\d+)\s+connectors/i);
+    const count = countMatch ? parseInt(countMatch[1], 10) : 0;
+    const connectors = [];
+    // Parse: name (source)
+    const lineRe = /^([^\s(]+)\s*\(([^)]+)\)/gm;
+    let m;
+    while ((m = lineRe.exec(output)) !== null) {
+        connectors.push(`${m[1].trim()} (${m[2].trim()})`);
+    }
+    return {
+        count,
+        connectors,
+        success: count > 0,
+    };
+}

package/dist/internal/lib/utils/path-detection.d.ts

@@ -0,0 +1,43 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * Path detection utility — robust regex-based file path detection in arbitrary text.
+ *
+ * Used across the entire frontend to make file paths clickable wherever they appear:
+ * markdown, terminal output, tool results, etc.
+ */
+export interface PathSegment {
+    type: 'text' | 'path';
+    value: string;
+    /** The clean file path (without :line:col) */
+    filePath?: string;
+    /** Line number if present (e.g. from `:42`) */
+    lineNumber?: number;
+    /** Column number if present (e.g. from `:42:15`) */
+    column?: number;
+}
+export interface PathMatch {
+    /** The full matched string including :line:col */
+    fullMatch: string;
+    /** The clean file path without :line:col */
+    filePath: string;
+    /** Start index in the source text */
+    start: number;
+    /** End index in the source text */
+    end: number;
+    /** Line number if present */
+    lineNumber?: number;
+    /** Column number if present */
+    column?: number;
+}
+/** Heuristic: does this string look like a file path? */
+export declare function looksLikeFilePath(text: string): boolean;
+/**
+ * Find all file path matches in a block of text.
+ * Returns an array of PathMatch objects with positions and parsed line/col.
+ */
+export declare function detectFilePaths(text: string): PathMatch[];
+/**
+ * Split text into alternating text and path segments.
+ * This is the primary function used by rendering components.
+ */
+export declare function splitTextByPaths(text: string): PathSegment[];