@researchcomputer/pista 0.1.2 → 0.1.3

package/dist/components/scrollbar.js

@@ -3,7 +3,7 @@ import React from 'react';
 import { Box, Text } from 'ink';
 export const Scrollbar = React.memo(function Scrollbar({ trackHeight, totalEntries, visibleEntries, offset, }) {
     if (totalEntries <= visibleEntries || trackHeight < 1) {
-        return (_jsx(Box, { flexDirection: "column", width: 2, children: Array.from({ length: trackHeight }, (_, i) => (_jsx(Text, { dimColor: true, children: " " }, i))) }));
+        return (_jsx(Box, { flexDirection: "column", width: 2, children: Array.from({ length: trackHeight }, (_, i) => (_jsx(Text, { dimColor: true, children: ' ' }, i))) }));
     }
     const thumbSize = Math.max(1, Math.round((visibleEntries / totalEntries) * trackHeight));
     const maxOffset = totalEntries - visibleEntries;

package/dist/components/status-bar.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export const StatusBar = React.memo(function StatusBar({ running, status, spinnerFrame, btwActive = false, }) {
+    return (_jsxs(Box, { paddingX: 1, justifyContent: "space-between", marginBottom: 0, children: [_jsx(Text, { dimColor: true, children: running ? 'Ctrl+C abort' : 'Ctrl+C exit' }), _jsx(Box, { children: running ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "cyanBright", children: SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length] }), _jsxs(Text, { color: btwActive ? 'magentaBright' : 'yellowBright', children: [btwActive ? ' btw · ' : ' ', status] })] })) : btwActive ? (_jsx(Text, { color: "magentaBright", children: "\u25CF btw" })) : (_jsx(Text, { color: "greenBright", children: "\u25CF ready" })) })] }));
+});

package/dist/hooks/use-composer.js

@@ -0,0 +1,89 @@
+import { useCallback, useState } from 'react';
+export function useComposer() {
+    const [composer, setComposer] = useState({ value: '', cursor: 0 });
+    const [history, setHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(null);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_draftBeforeHistory, setDraftBeforeHistory] = useState(null);
+    const remember = useCallback((value) => {
+        setHistory((current) => {
+            const trimmed = value.trim();
+            if (!trimmed)
+                return current;
+            const deduped = current.filter((entry) => entry !== value);
+            return [...deduped, value].slice(-50);
+        });
+    }, []);
+    const clear = useCallback(() => {
+        setComposer({ value: '', cursor: 0 });
+        setHistoryIndex(null);
+        setDraftBeforeHistory(null);
+    }, []);
+    const navigateHistory = useCallback((direction) => {
+        if (direction === 'up') {
+            setHistory((currentHistory) => {
+                if (currentHistory.length === 0)
+                    return currentHistory;
+                setHistoryIndex((current) => {
+                    const nextIndex = current === null ? currentHistory.length - 1 : Math.max(0, current - 1);
+                    setDraftBeforeHistory((draft) => draft ?? composer);
+                    const nextValue = currentHistory[nextIndex] ?? '';
+                    setComposer({ value: nextValue, cursor: nextValue.length });
+                    return nextIndex;
+                });
+                return currentHistory;
+            });
+        }
+        else {
+            setHistory((currentHistory) => {
+                if (currentHistory.length === 0)
+                    return currentHistory;
+                setHistoryIndex((currentIndex) => {
+                    if (currentIndex === null)
+                        return currentIndex;
+                    if (currentIndex >= currentHistory.length - 1) {
+                        setDraftBeforeHistory((draft) => {
+                            setComposer(draft ?? { value: '', cursor: 0 });
+                            return null;
+                        });
+                        return null;
+                    }
+                    const nextIndex = currentIndex + 1;
+                    const nextValue = currentHistory[nextIndex] ?? '';
+                    setComposer({ value: nextValue, cursor: nextValue.length });
+                    return nextIndex;
+                });
+                return currentHistory;
+            });
+        }
+    }, [composer]);
+    const insertNewline = useCallback(() => {
+        setComposer((current) => {
+            const nextValue = `${current.value.slice(0, current.cursor)}\n${current.value.slice(current.cursor)}`;
+            return { value: nextValue, cursor: current.cursor + 1 };
+        });
+        setHistoryIndex(null);
+        setDraftBeforeHistory(null);
+    }, []);
+    const applySelection = useCallback((insertText) => {
+        setComposer({ value: insertText, cursor: insertText.length });
+        setHistoryIndex(null);
+        setDraftBeforeHistory(null);
+    }, []);
+    const resetHistoryNavigation = useCallback(() => {
+        setHistoryIndex(null);
+        setDraftBeforeHistory(null);
+    }, []);
+    return {
+        composer,
+        setComposer,
+        history,
+        historyIndex,
+        remember,
+        clear,
+        navigateHistory,
+        insertNewline,
+        applySelection,
+        resetHistoryNavigation,
+    };
+}

package/dist/hooks/use-composer.test.js

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+test('composer history deduplicates entries', () => {
+    const current = ['hello', 'world'];
+    const value = 'hello';
+    const deduped = current.filter((entry) => entry !== value);
+    const result = [...deduped, value].slice(-50);
+    assert.deepEqual(result, ['world', 'hello']);
+});
+test('composer history caps at 50 entries', () => {
+    const current = Array.from({ length: 50 }, (_, i) => `entry-${i}`);
+    const value = 'new-entry';
+    const deduped = current.filter((entry) => entry !== value);
+    const result = [...deduped, value].slice(-50);
+    assert.equal(result.length, 50);
+    assert.equal(result[49], 'new-entry');
+    assert.equal(result[0], 'entry-1');
+});
+test('empty or whitespace-only values are not added to history', () => {
+    const values = ['', '  ', '\n', '\t'];
+    for (const value of values) {
+        assert.ok(!value.trim(), `"${value}" should be empty after trim`);
+    }
+});

package/dist/hooks/use-live-assistant.js

@@ -0,0 +1,64 @@
+import { useCallback, useMemo, useRef, useState } from 'react';
+export function useLiveAssistant() {
+    const bufferRef = useRef('');
+    const flushTimerRef = useRef(null);
+    const mountedRef = useRef(true);
+    const [text, setText] = useState('');
+    const textRef = useRef(text);
+    textRef.current = text;
+    const flush = useCallback(() => {
+        if (flushTimerRef.current) {
+            clearTimeout(flushTimerRef.current);
+            flushTimerRef.current = null;
+        }
+        if (!mountedRef.current)
+            return;
+        const next = bufferRef.current;
+        setText((current) => (current === next ? current : next));
+    }, []);
+    const scheduleFlush = useCallback(() => {
+        if (flushTimerRef.current)
+            return;
+        flushTimerRef.current = setTimeout(() => {
+            flushTimerRef.current = null;
+            if (!mountedRef.current)
+                return;
+            const next = bufferRef.current;
+            setText((current) => (current === next ? current : next));
+        }, 33);
+    }, []);
+    const appendDelta = useCallback((delta) => {
+        if (!delta)
+            return;
+        bufferRef.current += delta;
+        scheduleFlush();
+    }, [scheduleFlush]);
+    const clear = useCallback(() => {
+        if (flushTimerRef.current) {
+            clearTimeout(flushTimerRef.current);
+            flushTimerRef.current = null;
+        }
+        bufferRef.current = '';
+        setText((current) => (current ? '' : current));
+    }, []);
+    const getText = useCallback(() => {
+        flush();
+        return bufferRef.current;
+    }, [flush]);
+    const cleanup = useCallback(() => {
+        mountedRef.current = false;
+        if (flushTimerRef.current) {
+            clearTimeout(flushTimerRef.current);
+            flushTimerRef.current = null;
+        }
+    }, []);
+    return useMemo(() => ({
+        get text() {
+            return textRef.current;
+        },
+        appendDelta,
+        clear,
+        getText,
+        cleanup,
+    }), [appendDelta, clear, getText, cleanup]);
+}

package/dist/hooks/use-live-assistant.test.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { PassThrough } from 'node:stream';
+import { setTimeout as delay } from 'node:timers/promises';
+import { useEffect, useState } from 'react';
+import { render, Text } from 'ink';
+import { useLiveAssistant } from './use-live-assistant.js';
+test('useLiveAssistant keeps a stable object across unrelated rerenders', async () => {
+    let rerender;
+    let effectRuns = 0;
+    function Harness() {
+        const [count, setCount] = useState(0);
+        const liveAssistant = useLiveAssistant();
+        rerender = () => setCount((current) => current + 1);
+        useEffect(() => {
+            effectRuns += 1;
+        }, [liveAssistant]);
+        return _jsx(Text, { children: count });
+    }
+    const stdout = new PassThrough();
+    const stdin = new PassThrough();
+    const app = render(_jsx(Harness, {}), { stdout, stdin, stderr: stdout, exitOnCtrlC: false, patchConsole: false });
+    await delay(50);
+    rerender?.();
+    await delay(50);
+    app.unmount();
+    await app.waitUntilExit();
+    assert.equal(effectRuns, 1);
+});

package/dist/hooks/use-terminal-size.js

@@ -0,0 +1,21 @@
+import { useState, useEffect } from 'react';
+import process from 'node:process';
+export function useTerminalSize() {
+    const [size, setSize] = useState({
+        columns: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24,
+    });
+    useEffect(() => {
+        const onResize = () => {
+            setSize({
+                columns: process.stdout.columns || 80,
+                rows: process.stdout.rows || 24,
+            });
+        };
+        process.stdout.on('resize', onResize);
+        return () => {
+            process.stdout.off('resize', onResize);
+        };
+    }, []);
+    return size;
+}

package/dist/transcript.test.js

@@ -31,3 +31,25 @@ test('getTranscriptOffsetForEntry centers the requested entry when possible', ()
     assert.equal(getTranscriptOffsetForEntry(20, 5, 0), 15);
     assert.equal(getTranscriptOffsetForEntry(20, 5, 19), 0);
 });
+test('getTranscriptWindow handles zero entries', () => {
+    const window = getTranscriptWindow(0, 10, 0);
+    assert.equal(window.start, 0);
+    assert.equal(window.end, 0);
+    assert.equal(window.offset, 0);
+    assert.equal(window.maxOffset, 0);
+});
+test('getTranscriptWindow handles more visible rows than entries', () => {
+    const window = getTranscriptWindow(3, 10, 0);
+    assert.equal(window.start, 0);
+    assert.equal(window.end, 3);
+    assert.equal(window.offset, 0);
+});
+test('stepTranscriptOffset clamps to bounds', () => {
+    const result = stepTranscriptOffset(0, 100, 5, 10);
+    assert.equal(result, 0);
+});
+test('getTranscriptOffsetForEntry centers the target entry', () => {
+    const offset = getTranscriptOffsetForEntry(20, 5, 10);
+    assert.ok(offset >= 0);
+    assert.ok(offset <= 15);
+});

package/dist/utils.js

@@ -86,9 +86,7 @@ export function mergeStoredSkills(base = [], override = []) {
     return orderedIds.map((id) => merged.get(id));
 }
 export function resolveConfiguredSkills(skills = []) {
-    return skills
-        .filter((skill) => skill.enabled !== false)
-        .map(({ enabled: _enabled, ...skill }) => skill);
+    return skills.filter((skill) => skill.enabled !== false).map(({ enabled: _enabled, ...skill }) => skill);
 }
 export function truncate(value, maxLength) {
     if (value.length <= maxLength)
@@ -201,11 +199,31 @@ export async function fetchGitHubSkill(source) {
  */
 export async function fetchGitHubSkillIndex(owner, repo) {
     const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/HEAD/.claude-plugin/marketplace.json`;
-    const response = await fetch(rawUrl);
+    let response;
+    try {
+        response = await fetch(rawUrl);
+    }
+    catch {
+        return null;
+    }
     if (!response.ok)
         return null;
-    const data = await response.json();
-    return data.plugins ?? null;
+    let data;
+    try {
+        data = await response.json();
+    }
+    catch {
+        return null;
+    }
+    if (!data || typeof data !== 'object')
+        return null;
+    const plugins = data.plugins;
+    if (!Array.isArray(plugins))
+        return null;
+    return plugins.filter((p) => typeof p === 'object' &&
+        p !== null &&
+        typeof p.name === 'string' &&
+        Array.isArray(p.skills));
 }
 export function normalizeEndpoint(value) {
     const parsed = new URL(value);

package/dist/utils.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { getCliMemoryDir, getCliPreferencesPath, getCliSessionsDir, loadResolvedPreferences, loadStoredPreferences, mergeStoredSkills, mergeStoredPreferences, normalizeAgentName, resolveConfiguredSkills, saveStoredPreferences, } from './utils.js';
+import { errorMessage, getCliMemoryDir, getCliPreferencesPath, getCliSessionsDir, loadResolvedPreferences, loadStoredPreferences, logColor, mergeStoredSkills, mergeStoredPreferences, normalizeAgentName, parseSkillFrontmatter, resolveConfiguredSkills, saveStoredPreferences, stringifyPreview, } from './utils.js';
 test('CLI home-directory helpers resolve under the provided base directory', () => {
     const baseDir = '/tmp/pi-agent-home';
     assert.equal(getCliSessionsDir(baseDir), path.join(baseDir, '.pista', 'sessions'));
@@ -56,10 +56,12 @@ test('loadResolvedPreferences layers project preferences over global preferences
         selection: {
             model: 'project-model',
         },
-        skills: [{
+        skills: [
+            {
                 id: 'project-skill',
                 promptSections: ['Prefer concise summaries.'],
-            }],
+            },
+        ],
     }, projectDir);
     assert.deepEqual(loadResolvedPreferences(projectDir, homeDir), {
         selection: {
@@ -67,10 +69,12 @@ test('loadResolvedPreferences layers project preferences over global preferences
             endpoint: 'https://global.invalid/v1',
             apiStyle: 'chat',
         },
-        skills: [{
+        skills: [
+            {
                 id: 'project-skill',
                 promptSections: ['Prefer concise summaries.'],
-            }],
+            },
+        ],
     });
 });
 test('mergeStoredSkills replaces matching ids and preserves order', () => {
@@ -95,3 +99,47 @@ test('resolveConfiguredSkills filters disabled skills and strips CLI-only fields
 test('normalizeAgentName falls back to Pista when given blank input', () => {
     assert.equal(normalizeAgentName('   '), 'Pista');
 });
+test('errorMessage extracts Error message', () => {
+    assert.equal(errorMessage(new Error('boom')), 'boom');
+});
+test('errorMessage stringifies non-Error values', () => {
+    assert.equal(errorMessage('oops'), 'oops');
+    assert.equal(errorMessage(42), '42');
+    assert.equal(errorMessage(null), 'null');
+});
+test('stringifyPreview handles undefined', () => {
+    assert.equal(stringifyPreview(undefined, 100), '[no content]');
+});
+test('stringifyPreview truncates long JSON', () => {
+    const result = stringifyPreview({ key: 'a'.repeat(200) }, 50);
+    assert.ok(result.length <= 50);
+    assert.ok(result.endsWith('...'));
+});
+test('logColor returns correct colors', () => {
+    assert.equal(logColor('system'), 'blueBright');
+    assert.equal(logColor('user'), 'greenBright');
+    assert.equal(logColor('assistant'), 'cyanBright');
+    assert.equal(logColor('tool'), 'yellowBright');
+    assert.equal(logColor('error'), 'redBright');
+});
+test('normalizeAgentName trims and caps length', () => {
+    assert.equal(normalizeAgentName('  My Agent  '), 'My Agent');
+    assert.equal(normalizeAgentName('a'.repeat(30)), 'a'.repeat(24));
+    assert.equal(normalizeAgentName(''), 'Pista');
+    assert.equal(normalizeAgentName('   '), 'Pista');
+});
+test('parseSkillFrontmatter returns null for no frontmatter', () => {
+    assert.equal(parseSkillFrontmatter('just text'), null);
+});
+test('parseSkillFrontmatter parses valid frontmatter', () => {
+    const content = '---\nname: test-skill\ndescription: A test\n---\nBody content here';
+    const result = parseSkillFrontmatter(content);
+    assert.ok(result);
+    assert.equal(result.name, 'test-skill');
+    assert.equal(result.description, 'A test');
+    assert.equal(result.body, 'Body content here');
+});
+test('parseSkillFrontmatter returns null for missing name', () => {
+    const content = '---\ndescription: No name field\n---\nBody';
+    assert.equal(parseSkillFrontmatter(content), null);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@researchcomputer/pista",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A lightweight CLI agent interface built with Ink",
   "type": "module",
   "bin": {
@@ -13,7 +13,12 @@
     "build": "tsc -p tsconfig.json",
     "start": "node dist/index.js",
     "prepublishOnly": "npm run build",
-    "test": "npm run build && node --test dist/*.test.js dist/**/*.test.js"
+    "test": "npm run build && node --test dist/*.test.js dist/**/*.test.js",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write src/",
+    "format:check": "prettier --check src/",
+    "dev": "tsc -p tsconfig.json --watch"
   },
   "dependencies": {
     "@researchcomputer/agents-sdk": "^0.1.0",
@@ -22,8 +27,13 @@
     "react": "^19.2.4"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/react": "^19.2.14",
-    "typescript": "^5.8.0"
+    "eslint": "^10.1.0",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.8.1",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.58.0"
   },
   "license": "MIT",
   "repository": {