talos-code 0.0.1 → 0.2.0

package/dist/tui/diff-model.js

@@ -0,0 +1,77 @@
+function row(kind, text, oldLine = null, newLine = null) { return { kind, text, oldLine, newLine }; }
+function headerPaths(line) {
+    const body = line.slice('diff --git '.length);
+    const quoted = [...body.matchAll(/"((?:\\.|[^"])*)"|([^\s]+)/gu)].map(match => (match[1] ?? match[2] ?? '').replace(/\\(["\\])/gu, '$1'));
+    return { oldPath: quoted[0] ?? '', newPath: quoted[1] ?? '' };
+}
+function pathHeader(line) { return line.slice(4).split('\t')[0] ?? ''; }
+export function parseUnifiedDiff(input) {
+    const source = String(input ?? '');
+    if (!source.trim() || source.trim() === '(no changes)')
+        return { files: [], plain: source.trim() === '(no changes)' ? [row('plain', '(no changes)')] : [], empty: true };
+    const lines = source.split(/\r?\n/u), files = [], plain = [];
+    let current = null;
+    let oldLine = null, newLine = null, inHunk = false;
+    const finish = () => { if (current) {
+        files.push(current);
+        current = null;
+    } oldLine = null; newLine = null; inHunk = false; };
+    for (const line of lines) {
+        if (line.startsWith('diff --git ')) {
+            finish();
+            const paths = headerPaths(line);
+            current = { ...paths, rows: [] };
+            continue;
+        }
+        if (!current) {
+            plain.push(row('plain', line));
+            continue;
+        }
+        if (line.startsWith('--- ')) {
+            current.oldPath = pathHeader(line);
+            current.rows.push(row('meta', line));
+            inHunk = false;
+            continue;
+        }
+        if (line.startsWith('+++ ')) {
+            current.newPath = pathHeader(line);
+            current.rows.push(row('meta', line));
+            inHunk = false;
+            continue;
+        }
+        const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?:.*)$/u.exec(line);
+        if (hunk) {
+            oldLine = Number(hunk[1]);
+            newLine = Number(hunk[3]);
+            inHunk = true;
+            current.rows.push(row('hunk', line));
+            continue;
+        }
+        if (inHunk && line.startsWith('\')) {
+            current.rows.push(row('no-newline', line));
+            continue;
+        }
+        if (inHunk && line.startsWith('+')) {
+            current.rows.push(row('add', line.slice(1), null, newLine));
+            newLine = (newLine ?? 0) + 1;
+            continue;
+        }
+        if (inHunk && line.startsWith('-')) {
+            current.rows.push(row('remove', line.slice(1), oldLine, null));
+            oldLine = (oldLine ?? 0) + 1;
+            continue;
+        }
+        if (inHunk && line.startsWith(' ')) {
+            current.rows.push(row('context', line.slice(1), oldLine, newLine));
+            oldLine = (oldLine ?? 0) + 1;
+            newLine = (newLine ?? 0) + 1;
+            continue;
+        }
+        current.rows.push(row('meta', line));
+        inHunk = false;
+        oldLine = null;
+        newLine = null;
+    }
+    finish();
+    return { files, plain, empty: files.length === 0 && plain.every(item => item.text.trim() === '' || item.text.trim() === '(no changes)') };
+}

package/dist/tui/editor-history.js

@@ -0,0 +1,21 @@
+export const EDITOR_HISTORY_LIMIT = 100;
+export function createEditorHistory(limit = EDITOR_HISTORY_LIMIT) {
+    const bounded = Math.max(1, Math.trunc(limit));
+    return { past: [], future: [], limit: bounded };
+}
+function boundedTail(rows, limit) { return rows.length > limit ? rows.slice(rows.length - limit) : rows; }
+export function pushEditorHistory(history, value) {
+    return { past: boundedTail([...history.past, value], history.limit), future: [], limit: history.limit };
+}
+export function undoEditorHistory(history, current) {
+    if (history.past.length === 0)
+        return null;
+    const value = history.past[history.past.length - 1];
+    return { value, history: { past: history.past.slice(0, -1), future: [current, ...history.future].slice(0, history.limit), limit: history.limit } };
+}
+export function redoEditorHistory(history, current) {
+    if (history.future.length === 0)
+        return null;
+    const value = history.future[0];
+    return { value, history: { past: boundedTail([...history.past, current], history.limit), future: history.future.slice(1), limit: history.limit } };
+}

package/dist/tui/editor.js

@@ -0,0 +1,210 @@
+import { createEditorHistory, pushEditorHistory, redoEditorHistory, undoEditorHistory } from "./editor-history.js";
+import { splitGraphemes } from "./text-width.js";
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+const clonePastes = (pastes) => pastes.map(paste => ({ ...paste }));
+function clearPreferred(state) { const { preferredColumn: _, ...rest } = state; return rest; }
+function clearSelection(state) { const { selectionAnchor: _, ...rest } = state; return rest; }
+function clearTransient(state) { return clearSelection(clearPreferred(state)); }
+function snapshot(state) { return { text: state.text, cursor: clamp(state.cursor, 0, state.text.length), collapsedPastes: clonePastes(state.collapsedPastes) }; }
+function withCursor(state, cursor, extendSelection = false) {
+    const nextCursor = clamp(cursor, 0, state.text.length);
+    const base = clearPreferred(state);
+    if (!extendSelection)
+        return { ...clearSelection(base), cursor: nextCursor };
+    const anchor = state.selectionAnchor ?? clamp(state.cursor, 0, state.text.length);
+    if (anchor === nextCursor)
+        return { ...clearSelection(base), cursor: nextCursor };
+    return { ...base, cursor: nextCursor, selectionAnchor: anchor };
+}
+function restoreSnapshot(state, value, editHistory) {
+    return { ...clearTransient(state), text: value.text, cursor: clamp(value.cursor, 0, value.text.length), collapsedPastes: clonePastes(value.collapsedPastes), editHistory };
+}
+export function previousGraphemeBoundary(text, cursor) { let offset = 0, previous = 0; for (const g of splitGraphemes(text)) {
+    const next = offset + g.length;
+    if (next >= cursor)
+        return previous;
+    previous = next;
+    offset = next;
+} return previous; }
+export function nextGraphemeBoundary(text, cursor) { let offset = 0; for (const g of splitGraphemes(text)) {
+    offset += g.length;
+    if (offset > cursor)
+        return offset;
+} return text.length; }
+function graphemeBoundaryAtOrBefore(text, cursor) { const target = clamp(cursor, 0, text.length); let offset = 0; for (const g of splitGraphemes(text)) {
+    const next = offset + g.length;
+    if (next > target)
+        return offset;
+    if (next === target)
+        return next;
+    offset = next;
+} return text.length; }
+export function createEditorState(text = '') { return { text, cursor: text.length, killBuffer: '', collapsedPastes: [], editHistory: createEditorHistory() }; }
+export function replaceEditorText(_state, text) { return createEditorState(text); }
+export function draftOf(state) { return { text: state.text, collapsedPastes: clonePastes(state.collapsedPastes) }; }
+export function draftText(draft) { return typeof draft === 'string' ? draft : draft.text; }
+export function editorFromDraft(draft) {
+    const text = draftText(draft), state = createEditorState(text);
+    if (typeof draft === 'string')
+        return state;
+    const valid = draft.collapsedPastes.filter(paste => Number.isSafeInteger(paste.start) && Number.isSafeInteger(paste.end) && paste.start >= 0 && paste.end > paste.start && paste.end <= text.length);
+    const pastes = [...valid].sort((a, b) => a.start - b.start).filter((paste, index, sorted) => index === 0 || paste.start >= sorted[index - 1].end);
+    return { ...state, collapsedPastes: clonePastes(pastes) };
+}
+export function selectionRange(state) {
+    if (state.selectionAnchor === undefined)
+        return null;
+    const anchor = clamp(state.selectionAnchor, 0, state.text.length), cursor = clamp(state.cursor, 0, state.text.length);
+    if (anchor === cursor)
+        return null;
+    return { start: Math.min(anchor, cursor), end: Math.max(anchor, cursor) };
+}
+export function remapCollapsedPastes(pastes, editStart, removed, inserted) {
+    const editEnd = editStart + removed, delta = inserted - removed;
+    const out = [];
+    for (const p of pastes) {
+        if (editEnd <= p.start) {
+            out.push({ ...p, start: p.start + delta, end: p.end + delta });
+            continue;
+        }
+        if (editStart >= p.end) {
+            out.push({ ...p });
+            continue;
+        }
+    }
+    return out;
+}
+export function replaceRange(state, start, end, value) {
+    const from = clamp(start, 0, state.text.length), to = Math.max(from, clamp(end, 0, state.text.length));
+    if (from === to && value.length === 0)
+        return clearTransient(state);
+    const editHistory = pushEditorHistory(state.editHistory, snapshot(state));
+    return { ...clearTransient(state), text: state.text.slice(0, from) + value + state.text.slice(to), cursor: from + value.length, collapsedPastes: remapCollapsedPastes(state.collapsedPastes, from, to - from, value.length), editHistory };
+}
+export function editInsert(state, value) {
+    if (!value)
+        return clearPreferred(state);
+    const selected = selectionRange(state);
+    return selected ? replaceRange(state, selected.start, selected.end, value) : replaceRange(state, state.cursor, state.cursor, value);
+}
+export function moveCursor(state, to, extendSelection = false) {
+    const selected = selectionRange(state);
+    if (selected && !extendSelection && (to === 'left' || to === 'right'))
+        return withCursor(state, to === 'left' ? selected.start : selected.end, false);
+    const bounds = lineBounds(state.text, state.cursor);
+    const cursor = to === 'left' ? previousGraphemeBoundary(state.text, state.cursor) : to === 'right' ? nextGraphemeBoundary(state.text, state.cursor) : to === 'home' ? bounds.start : bounds.end;
+    return withCursor(state, cursor, extendSelection);
+}
+function isWord(ch) { return !!ch && /[\p{L}\p{N}_]/u.test(ch); }
+export function moveWord(state, direction, extendSelection = false) { let c = clamp(state.cursor, 0, state.text.length); if (direction < 0) {
+    while (c > 0 && !isWord(state.text[previousGraphemeBoundary(state.text, c)]))
+        c = previousGraphemeBoundary(state.text, c);
+    while (c > 0 && isWord(state.text[previousGraphemeBoundary(state.text, c)]))
+        c = previousGraphemeBoundary(state.text, c);
+}
+else {
+    while (c < state.text.length && !isWord(state.text[c]))
+        c = nextGraphemeBoundary(state.text, c);
+    while (c < state.text.length && isWord(state.text[c]))
+        c = nextGraphemeBoundary(state.text, c);
+} return withCursor(state, c, extendSelection); }
+function lineBounds(text, cursor) { const c = clamp(cursor, 0, text.length); const start = text.lastIndexOf('\n', Math.max(0, c - 1)) + 1; const next = text.indexOf('\n', c); const end = next < 0 ? text.length : next; return { start, end }; }
+export function moveVertical(state, direction, extendSelection = false) {
+    const c = clamp(state.cursor, 0, state.text.length);
+    const current = lineBounds(state.text, c);
+    const preferred = state.preferredColumn ?? (c - current.start);
+    if (direction < 0) {
+        if (current.start === 0)
+            return extendSelection ? state : withCursor(state, c, false);
+        const previousEnd = current.start - 1;
+        const previous = lineBounds(state.text, previousEnd);
+        const target = graphemeBoundaryAtOrBefore(state.text, previous.start + Math.min(preferred, previous.end - previous.start));
+        const moved = withCursor(state, target, extendSelection);
+        return { ...moved, preferredColumn: preferred };
+    }
+    if (current.end === state.text.length)
+        return extendSelection ? state : withCursor(state, c, false);
+    const nextStart = current.end + 1;
+    const next = lineBounds(state.text, nextStart);
+    const target = graphemeBoundaryAtOrBefore(state.text, next.start + Math.min(preferred, next.end - next.start));
+    const moved = withCursor(state, target, extendSelection);
+    return { ...moved, preferredColumn: preferred };
+}
+export function deleteBackward(state) { const selected = selectionRange(state); if (selected)
+    return replaceRange(state, selected.start, selected.end, ''); const c = clamp(state.cursor, 0, state.text.length); if (c === 0)
+    return clearPreferred(state); return replaceRange(state, previousGraphemeBoundary(state.text, c), c, ''); }
+export function deleteForward(state) { const selected = selectionRange(state); if (selected)
+    return replaceRange(state, selected.start, selected.end, ''); const c = clamp(state.cursor, 0, state.text.length); if (c >= state.text.length)
+    return clearPreferred(state); return replaceRange(state, c, nextGraphemeBoundary(state.text, c), ''); }
+export function copySelection(state) { const selected = selectionRange(state); return selected ? { ...state, killBuffer: state.text.slice(selected.start, selected.end) } : state; }
+export function cutSelection(state) { const selected = selectionRange(state); if (!selected)
+    return state; const killed = state.text.slice(selected.start, selected.end); return { ...replaceRange(state, selected.start, selected.end, ''), killBuffer: killed }; }
+export function killToStart(state) { if (selectionRange(state))
+    return cutSelection(state); const c = clamp(state.cursor, 0, state.text.length); const { start } = lineBounds(state.text, c); if (c === start)
+    return clearPreferred(state); const killed = state.text.slice(start, c); return { ...replaceRange(state, start, c, ''), killBuffer: killed }; }
+export function killToEnd(state) { if (selectionRange(state))
+    return cutSelection(state); const c = clamp(state.cursor, 0, state.text.length); const { end } = lineBounds(state.text, c); if (c >= end)
+    return clearPreferred(state); const killed = state.text.slice(c, end); return { ...replaceRange(state, c, end, ''), killBuffer: killed }; }
+export function killWordBackward(state) { if (selectionRange(state))
+    return cutSelection(state); const end = clamp(state.cursor, 0, state.text.length); const moved = moveWord(state, -1); if (moved.cursor === end)
+    return clearPreferred(state); const killed = state.text.slice(moved.cursor, end); return { ...replaceRange(state, moved.cursor, end, ''), killBuffer: killed }; }
+export function yank(state) { return state.killBuffer ? editInsert(state, state.killBuffer) : clearPreferred(state); }
+export function undoEditor(state) { const step = undoEditorHistory(state.editHistory, snapshot(state)); return step ? restoreSnapshot(state, step.value, step.history) : clearTransient(state); }
+export function redoEditor(state) { const step = redoEditorHistory(state.editHistory, snapshot(state)); return step ? restoreSnapshot(state, step.value, step.history) : clearTransient(state); }
+export function visibleEditorText(state) { const c = clamp(state.cursor, 0, state.text.length); const next = nextGraphemeBoundary(state.text, c); return { before: state.text.slice(0, c), cursor: state.text.slice(c, next) || ' ', after: state.text.slice(next), atEnd: c === state.text.length }; }
+export function insertPaste(state, text) {
+    const selected = selectionRange(state);
+    const start = selected?.start ?? state.cursor;
+    const end = selected?.end ?? state.cursor;
+    const next = replaceRange(state, start, end, text);
+    const lines = text.split(/\r?\n/u).length;
+    return text.length >= 4096 || lines >= 20 ? { ...next, collapsedPastes: [...next.collapsedPastes, { start, end: start + text.length, chars: text.length, lines }] } : next;
+}
+export function composerSegments(state) {
+    const out = [];
+    const ranges = [...state.collapsedPastes].sort((a, b) => a.start - b.start);
+    const selected = selectionRange(state);
+    const pushText = (start, end) => {
+        if (end < start)
+            return;
+        if (selected) {
+            const selectedStart = Math.max(start, selected.start), selectedEnd = Math.min(end, selected.end);
+            if (selectedEnd <= selectedStart) {
+                if (end > start)
+                    out.push({ kind: 'text', text: state.text.slice(start, end) });
+                return;
+            }
+            if (selectedStart > start)
+                out.push({ kind: 'text', text: state.text.slice(start, selectedStart) });
+            out.push({ kind: 'text', text: state.text.slice(selectedStart, selectedEnd), selected: true });
+            if (selectedEnd < end)
+                out.push({ kind: 'text', text: state.text.slice(selectedEnd, end) });
+            return;
+        }
+        if (state.cursor < start || state.cursor > end) {
+            if (end > start)
+                out.push({ kind: 'text', text: state.text.slice(start, end) });
+            return;
+        }
+        if (state.cursor > start)
+            out.push({ kind: 'text', text: state.text.slice(start, state.cursor) });
+        const next = Math.min(end, nextGraphemeBoundary(state.text, state.cursor));
+        out.push({ kind: 'cursor', text: state.text.slice(state.cursor, next) || ' ' });
+        if (next < end)
+            out.push({ kind: 'text', text: state.text.slice(next, end) });
+    };
+    let pos = 0;
+    for (const p of ranges) {
+        if (p.start < pos)
+            continue;
+        pushText(pos, p.start);
+        const pasteSelected = Boolean(selected && selected.end > p.start && selected.start < p.end);
+        if (!selected && state.cursor >= p.start && state.cursor < p.end)
+            pushText(p.start, p.end);
+        else
+            out.push({ kind: 'paste', text: '[paste: ' + p.lines + ' lines, ' + p.chars + ' chars]', ...(pasteSelected ? { selected: true } : {}) });
+        pos = p.end;
+    }
+    pushText(pos, state.text.length);
+    return out;
+}