@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

package/dist/integrations/pi/components/upstream/components/session-footer.js

@@ -0,0 +1,123 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/components/footer.ts.
+ * Modifications: Consumes neutral owned-UI view data instead of a fabricated concrete AgentSession; an
+ * explicit bare-A1 profile colors the thinking-level name while preserving the remaining footer layout
+ * and formatting.
+ * Deviations: owned-status-level-color.
+ */
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { piTheme } from "../../theme.js";
+export class SessionFooter {
+    getView;
+    cwd;
+    profile;
+    constructor(getView, cwd, profile = "pi") { this.getView = getView; this.cwd = cwd; this.profile = profile; }
+    invalidate() { }
+    dispose() { }
+    render(width) {
+        const view = this.getView();
+        const usage = view.status.usage;
+        const theme = piTheme();
+        const input = usage?.input ?? 0;
+        const output = usage?.output ?? 0;
+        const cacheRead = usage?.cacheRead ?? 0;
+        const cacheWrite = usage?.cacheWrite ?? 0;
+        const cost = usage?.cost ?? 0;
+        const contextWindow = usage?.contextWindow ?? 0;
+        const contextPercentValue = usage?.contextPercent ?? 0;
+        const contextPercentSource = usage?.contextAvailable === false ? undefined : usage?.contextPercent;
+        const contextPercent = contextPercentSource !== null ? contextPercentValue.toFixed(1) : "?";
+        let pwd = formatCwd(this.cwd, process.env.HOME || process.env.USERPROFILE);
+        const branch = view.status.footer?.branch;
+        if (branch)
+            pwd = `${pwd} (${branch})`;
+        const sessionName = view.status.footer?.sessionName;
+        if (sessionName)
+            pwd = `${pwd} • ${sessionName}`;
+        const parts = [];
+        if (input)
+            parts.push(`↑${formatTokens(input)}`);
+        if (output)
+            parts.push(`↓${formatTokens(output)}`);
+        if (cacheRead)
+            parts.push(`R${formatTokens(cacheRead)}`);
+        if (cacheWrite)
+            parts.push(`W${formatTokens(cacheWrite)}`);
+        if ((cacheRead > 0 || cacheWrite > 0) && usage?.latestCacheHitRate !== null && usage?.latestCacheHitRate !== undefined)
+            parts.push(`CH${usage.latestCacheHitRate.toFixed(1)}%`);
+        if (cost || usage?.usingSubscription)
+            parts.push(`$${cost.toFixed(3)}${usage?.usingSubscription ? " (sub)" : ""}`);
+        const autoIndicator = usage?.autoCompactEnabled === false ? "" : " (auto)";
+        const contextDisplay = contextPercent === "?"
+            ? `?/${formatTokens(contextWindow)}${autoIndicator}`
+            : `${contextPercent}%/${formatTokens(contextWindow)}${autoIndicator}`;
+        parts.push(contextPercentValue > 90 ? theme.fg("error", contextDisplay) : contextPercentValue > 70 ? theme.fg("warning", contextDisplay) : contextDisplay);
+        let left = parts.join(" ");
+        let leftWidth = visibleWidth(left);
+        if (leftWidth > width) {
+            left = truncateToWidth(left, width, "...");
+            leftWidth = visibleWidth(left);
+        }
+        const modelName = view.activeModel?.modelId ?? "no-model";
+        const rightWithoutProvider = this.profile === "a1"
+            ? view.activeModel === null ? theme.fg("dim", modelName)
+                : theme.fg("dim", `${modelName} • `) + theme.getThinkingBorderColor(view.thinkingLevel)(view.thinkingLevel)
+            : view.activeModel === null || view.thinkingLevel === "off" ? modelName : `${modelName} • ${view.thinkingLevel}`;
+        let right = rightWithoutProvider;
+        if ((view.status.footer?.availableProviderCount ?? 1) > 1 && view.activeModel) {
+            const provider = `(${view.activeModel.providerId}) `;
+            right = (this.profile === "a1" ? theme.fg("dim", provider) : provider) + rightWithoutProvider;
+            if (leftWidth + 2 + visibleWidth(right) > width)
+                right = rightWithoutProvider;
+        }
+        const rightWidth = visibleWidth(right);
+        let line;
+        if (leftWidth + 2 + rightWidth <= width) {
+            line = left + " ".repeat(width - leftWidth - rightWidth) + right;
+        }
+        else {
+            const available = width - leftWidth - 2;
+            if (available > 0) {
+                const truncated = truncateToWidth(right, available, "");
+                line = left + " ".repeat(Math.max(0, width - leftWidth - visibleWidth(truncated))) + truncated;
+            }
+            else
+                line = left;
+        }
+        const lines = [
+            truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "...")),
+            theme.fg("dim", left) + (this.profile === "a1" ? line.slice(left.length) : theme.fg("dim", line.slice(left.length))),
+        ];
+        const statuses = view.status.footer?.extensionStatuses ?? [];
+        if (statuses.length > 0) {
+            const status = [...statuses].sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([, text]) => sanitize(text)).join(" ");
+            lines.push(truncateToWidth(status, width, theme.fg("dim", "...")));
+        }
+        return lines;
+    }
+}
+function sanitize(text) { return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim(); }
+function formatTokens(count) {
+    if (count < 1000)
+        return count.toString();
+    if (count < 10000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1000000)
+        return `${Math.round(count / 1000)}k`;
+    if (count < 10000000)
+        return `${(count / 1000000).toFixed(1)}M`;
+    return `${Math.round(count / 1000000)}M`;
+}
+function formatCwd(cwd, home) {
+    if (!home)
+        return cwd;
+    const resolvedCwd = resolve(cwd);
+    const resolvedHome = resolve(home);
+    const relativeToHome = relative(resolvedHome, resolvedCwd);
+    const inside = relativeToHome === "" || (relativeToHome !== ".." && !relativeToHome.startsWith(`..${sep}`) && !isAbsolute(relativeToHome));
+    if (!inside)
+        return cwd;
+    return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
+}

package/dist/integrations/pi/components/upstream/components/session-selector-search.js

@@ -0,0 +1,161 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/components/session-selector-search.ts.
+ * Modifications: Source-synchronized session search port with only the public SessionInfo type import
+ * remapped.
+ * Deviations: none.
+ */
+import { fuzzyMatch } from "@earendil-works/pi-tui";
+function normalizeWhitespaceLower(text) {
+    return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function getSessionSearchText(session) {
+    return `${session.id} ${session.name ?? ""} ${session.allMessagesText} ${session.cwd}`;
+}
+export function hasSessionName(session) {
+    return Boolean(session.name?.trim());
+}
+function matchesNameFilter(session, filter) {
+    if (filter === "all")
+        return true;
+    return hasSessionName(session);
+}
+export function parseSearchQuery(query) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+        return { mode: "tokens", tokens: [], regex: null };
+    }
+    // Regex mode: re:<pattern>
+    if (trimmed.startsWith("re:")) {
+        const pattern = trimmed.slice(3).trim();
+        if (!pattern) {
+            return { mode: "regex", tokens: [], regex: null, error: "Empty regex" };
+        }
+        try {
+            return { mode: "regex", tokens: [], regex: new RegExp(pattern, "i") };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { mode: "regex", tokens: [], regex: null, error: msg };
+        }
+    }
+    // Token mode with quote support.
+    // Example: foo "node cve" bar
+    const tokens = [];
+    let buf = "";
+    let inQuote = false;
+    let hadUnclosedQuote = false;
+    const flush = (kind) => {
+        const v = buf.trim();
+        buf = "";
+        if (!v)
+            return;
+        tokens.push({ kind, value: v });
+    };
+    for (let i = 0; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (ch === '"') {
+            if (inQuote) {
+                flush("phrase");
+                inQuote = false;
+            }
+            else {
+                flush("fuzzy");
+                inQuote = true;
+            }
+            continue;
+        }
+        if (!inQuote && /\s/.test(ch)) {
+            flush("fuzzy");
+            continue;
+        }
+        buf += ch;
+    }
+    if (inQuote) {
+        hadUnclosedQuote = true;
+    }
+    // If quotes were unbalanced, fall back to plain whitespace tokenization.
+    if (hadUnclosedQuote) {
+        return {
+            mode: "tokens",
+            tokens: trimmed
+                .split(/\s+/)
+                .map((t) => t.trim())
+                .filter((t) => t.length > 0)
+                .map((t) => ({ kind: "fuzzy", value: t })),
+            regex: null,
+        };
+    }
+    flush(inQuote ? "phrase" : "fuzzy");
+    return { mode: "tokens", tokens, regex: null };
+}
+export function matchSession(session, parsed) {
+    const text = getSessionSearchText(session);
+    if (parsed.mode === "regex") {
+        if (!parsed.regex) {
+            return { matches: false, score: 0 };
+        }
+        const idx = text.search(parsed.regex);
+        if (idx < 0)
+            return { matches: false, score: 0 };
+        return { matches: true, score: idx * 0.1 };
+    }
+    if (parsed.tokens.length === 0) {
+        return { matches: true, score: 0 };
+    }
+    let totalScore = 0;
+    let normalizedText = null;
+    for (const token of parsed.tokens) {
+        if (token.kind === "phrase") {
+            if (normalizedText === null) {
+                normalizedText = normalizeWhitespaceLower(text);
+            }
+            const phrase = normalizeWhitespaceLower(token.value);
+            if (!phrase)
+                continue;
+            const idx = normalizedText.indexOf(phrase);
+            if (idx < 0)
+                return { matches: false, score: 0 };
+            totalScore += idx * 0.1;
+            continue;
+        }
+        const m = fuzzyMatch(token.value, text);
+        if (!m.matches)
+            return { matches: false, score: 0 };
+        totalScore += m.score;
+    }
+    return { matches: true, score: totalScore };
+}
+export function filterAndSortSessions(sessions, query, sortMode, nameFilter = "all") {
+    const nameFiltered = nameFilter === "all" ? sessions : sessions.filter((session) => matchesNameFilter(session, nameFilter));
+    const trimmed = query.trim();
+    if (!trimmed)
+        return nameFiltered;
+    const parsed = parseSearchQuery(query);
+    if (parsed.error)
+        return [];
+    // Recent mode: filter only, keep incoming order.
+    if (sortMode === "recent") {
+        const filtered = [];
+        for (const s of nameFiltered) {
+            const res = matchSession(s, parsed);
+            if (res.matches)
+                filtered.push(s);
+        }
+        return filtered;
+    }
+    // Relevance mode: sort by score, tie-break by modified desc.
+    const scored = [];
+    for (const s of nameFiltered) {
+        const res = matchSession(s, parsed);
+        if (!res.matches)
+            continue;
+        scored.push({ session: s, score: res.score });
+    }
+    scored.sort((a, b) => {
+        if (a.score !== b.score)
+            return a.score - b.score;
+        return b.session.modified.getTime() - a.session.modified.getTime();
+    });
+    return scored.map((r) => r.session);
+}

package/dist/integrations/pi/components/upstream/components/session-selector.d.ts

@@ -0,0 +1,95 @@
+import { type Component, Container, type Focusable } from "@earendil-works/pi-tui";
+import { KeybindingsManager } from "../adjacent/core/keybindings.js";
+import { type SessionInfo } from "@earendil-works/pi-coding-agent";
+type SessionListProgress = (loaded: number, total: number) => void;
+import { type NameFilter, type SortMode } from "./session-selector-search.js";
+/**
+ * Custom session list component with multi-line items and search
+ */
+declare class SessionList implements Component, Focusable {
+    getSelectedSessionPath(): string | undefined;
+    private allSessions;
+    private filteredSessions;
+    private selectedIndex;
+    private searchInput;
+    private showCwd;
+    private sortMode;
+    private nameFilter;
+    private keybindings;
+    private showPath;
+    private confirmingDeletePath;
+    private currentSessionCanonicalPath;
+    onSelect?: (sessionPath: string) => void;
+    onCancel?: () => void;
+    onExit: () => void;
+    onToggleScope?: () => void;
+    onToggleSort?: () => void;
+    onToggleNameFilter?: () => void;
+    onTogglePath?: (showPath: boolean) => void;
+    onDeleteConfirmationChange?: (path: string | null) => void;
+    onDeleteSession?: (sessionPath: string) => Promise<void>;
+    onRenameSession?: (sessionPath: string) => void;
+    onError?: (message: string) => void;
+    private maxVisible;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(sessions: SessionInfo[], showCwd: boolean, sortMode: SortMode, nameFilter: NameFilter, keybindings: KeybindingsManager, currentSessionFilePath?: string);
+    setSortMode(sortMode: SortMode): void;
+    setNameFilter(nameFilter: NameFilter): void;
+    setSessions(sessions: SessionInfo[], showCwd: boolean): void;
+    private filterSessions;
+    private setConfirmingDeletePath;
+    private startDeleteConfirmationForSelectedSession;
+    private isCurrentSessionPath;
+    invalidate(): void;
+    render(width: number): string[];
+    private buildTreePrefix;
+    handleInput(keyData: string): void;
+}
+type SessionsLoader = (onProgress?: SessionListProgress) => Promise<SessionInfo[]>;
+/**
+ * Component that renders a session selector
+ */
+export declare class SessionSelectorComponent extends Container implements Focusable {
+    handleInput(data: string): void;
+    private canRename;
+    private sessionList;
+    private header;
+    private keybindings;
+    private scope;
+    private sortMode;
+    private nameFilter;
+    private currentSessions;
+    private allSessions;
+    private currentSessionsLoader;
+    private allSessionsLoader;
+    private requestRender;
+    private renameSession;
+    private currentLoading;
+    private allLoading;
+    private allLoadSeq;
+    private mode;
+    private renameInput;
+    private renameTargetPath;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    private buildBaseLayout;
+    constructor(currentSessionsLoader: SessionsLoader, allSessionsLoader: SessionsLoader, onSelect: (sessionPath: string) => void, onCancel: () => void, onExit: () => void, requestRender: () => void, options?: {
+        renameSession?: (sessionPath: string, currentName: string | undefined) => Promise<void>;
+        showRenameHint?: boolean;
+        keybindings?: KeybindingsManager;
+    }, currentSessionFilePath?: string);
+    private loadCurrentSessions;
+    private enterRenameMode;
+    private exitRenameMode;
+    private confirmRename;
+    private loadScope;
+    private toggleSortMode;
+    private toggleNameFilter;
+    private refreshSessionsAfterMutation;
+    private toggleScope;
+    getSessionList(): SessionList;
+}
+export {};