@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/loop/engine.js

@@ -0,0 +1,63 @@
+/**
+ * /loop — recurring prompts (background-tasks design §2.6).
+ *
+ * Pure decision logic kept out of the TUI, mirroring goal/engine.ts: the TUI
+ * owns a 1s ticker and calls decideLoopFiring per loop; this module owns
+ * parsing, caps, and the defer-not-stack rule (a firing due while a turn is
+ * running reschedules with a notice instead of piling up).
+ */
+export const MAX_ACTIVE_LOOPS = 5;
+export const MIN_LOOP_INTERVAL_MS = 60_000;
+export function parseLoopCommand(raw) {
+    const rest = raw.trim().replace(/^\/loop\s*/, "").trim();
+    if (!rest)
+        return { action: "help" };
+    if (rest === "list")
+        return { action: "list" };
+    const stop = rest.match(/^stop(?:\s+(\d+))?$/);
+    if (stop) {
+        return { action: "stop", stopId: stop[1] ? Number(stop[1]) : undefined };
+    }
+    const match = rest.match(/^(\d+)([smh])\s+(.+)$/s);
+    if (!match) {
+        return {
+            action: "start",
+            error: "Usage: /loop <interval> <prompt> — interval like 90s, 5m, 1h (min 60s). Also: /loop list, /loop stop [id].",
+        };
+    }
+    const value = Number(match[1]);
+    const unit = match[2];
+    const multiplier = unit === "s" ? 1000 : unit === "m" ? 60_000 : 3_600_000;
+    const intervalMs = Math.max(MIN_LOOP_INTERVAL_MS, value * multiplier);
+    const prompt = match[3].trim();
+    if (!prompt) {
+        return { action: "start", error: "Usage: /loop <interval> <prompt> — the prompt is required." };
+    }
+    return { action: "start", intervalMs, prompt };
+}
+export function decideLoopFiring(loop, now, turnRunning) {
+    if (now < loop.nextFireAt)
+        return "wait";
+    return turnRunning ? "defer" : "fire";
+}
+export function formatLoopList(loops, now) {
+    if (loops.length === 0)
+        return "No active loops. Start one with /loop <interval> <prompt>.";
+    return loops
+        .map((loop) => {
+        const nextIn = Math.max(0, Math.round((loop.nextFireAt - now) / 1000));
+        return `#${loop.id} every ${formatInterval(loop.intervalMs)} · fired ${loop.fires}x · next in ${nextIn}s · ${truncate(loop.prompt, 60)}`;
+    })
+        .join("\n");
+}
+export function formatInterval(intervalMs) {
+    if (intervalMs % 3_600_000 === 0)
+        return `${intervalMs / 3_600_000}h`;
+    if (intervalMs % 60_000 === 0)
+        return `${intervalMs / 60_000}m`;
+    return `${Math.round(intervalMs / 1000)}s`;
+}
+function truncate(value, max) {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    return oneLine.length <= max ? oneLine : `${oneLine.slice(0, max - 1)}…`;
+}

package/dist/lsp/config.d.ts

@@ -0,0 +1,18 @@
+export interface LspServerConfig {
+    disabled?: boolean;
+    command?: string[];
+    extensions?: string[];
+    rootMarkers?: string[];
+    env?: Record<string, string>;
+    initializationOptions?: Record<string, unknown>;
+    languageId?: string;
+}
+export type BuiltinLspServerId = "typescript" | "deno" | "vue" | "eslint" | "oxlint";
+export type LspServerId = BuiltinLspServerId | string;
+export type LspConfig = boolean | Record<string, LspServerConfig>;
+export declare const BUILTIN_LSP_SERVER_IDS: readonly BuiltinLspServerId[];
+export declare function normalizeLspConfig(value: unknown): LspConfig | undefined;
+export declare function isLspEnabled(config: LspConfig | undefined): boolean;
+export declare function isLspServerEnabled(config: LspConfig | undefined, id: LspServerId): boolean;
+export declare function isTypeScriptLspEnabled(config: LspConfig | undefined): boolean;
+export declare function customLspServerEntries(config: LspConfig | undefined): Array<[string, LspServerConfig]>;

package/dist/lsp/config.js

@@ -0,0 +1,58 @@
+export const BUILTIN_LSP_SERVER_IDS = ["typescript", "deno", "vue", "eslint", "oxlint"];
+export function normalizeLspConfig(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const config = {};
+    for (const [id, value] of Object.entries(raw)) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const server = value;
+        const next = {};
+        if (typeof server.disabled === "boolean")
+            next.disabled = server.disabled;
+        if (isStringArray(server.command) && server.command.length > 0)
+            next.command = server.command;
+        if (isStringArray(server.extensions))
+            next.extensions = server.extensions;
+        if (isStringArray(server.rootMarkers))
+            next.rootMarkers = server.rootMarkers;
+        if (server.env && typeof server.env === "object" && !Array.isArray(server.env)) {
+            next.env = Object.fromEntries(Object.entries(server.env).filter((entry) => typeof entry[1] === "string"));
+        }
+        if (server.initializationOptions && typeof server.initializationOptions === "object" && !Array.isArray(server.initializationOptions)) {
+            next.initializationOptions = server.initializationOptions;
+        }
+        if (typeof server.languageId === "string")
+            next.languageId = server.languageId;
+        config[id] = next;
+    }
+    return config;
+}
+export function isLspEnabled(config) {
+    return config !== false;
+}
+export function isLspServerEnabled(config, id) {
+    if (!isLspEnabled(config))
+        return false;
+    if (config && typeof config === "object" && config[id]?.disabled)
+        return false;
+    return true;
+}
+export function isTypeScriptLspEnabled(config) {
+    return isLspServerEnabled(config, "typescript");
+}
+export function customLspServerEntries(config) {
+    if (!config || typeof config !== "object")
+        return [];
+    return Object.entries(config).filter(([id, server]) => !BUILTIN_LSP_SERVER_IDS.includes(id)
+        && Array.isArray(server.command)
+        && server.command.length > 0
+        && Array.isArray(server.extensions)
+        && server.extensions.length > 0);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}

package/dist/lsp/diagnostics.d.ts

@@ -0,0 +1,24 @@
+export interface LspDiagnostic {
+    range?: {
+        start?: {
+            line?: number;
+            character?: number;
+        };
+        end?: {
+            line?: number;
+            character?: number;
+        };
+    };
+    severity?: number;
+    code?: string | number;
+    source?: string;
+    message: string;
+}
+export interface FormatDiagnosticsOptions {
+    max?: number;
+    includeSummary?: boolean;
+}
+export declare function formatDiagnostics(filePath: string, diagnostics: LspDiagnostic[], cwd?: string, options?: FormatDiagnosticsOptions): string;
+export declare function formatDiagnosticBlocks(cwd: string, currentFile: string, diagnostics: Record<string, LspDiagnostic[]>): string;
+export declare function normalizeDiagnostics(diagnostics: LspDiagnostic[]): LspDiagnostic[];
+export declare function formatDiagnosticSummary(diagnostics: LspDiagnostic[]): string;

package/dist/lsp/diagnostics.js

@@ -0,0 +1,103 @@
+import { relative } from "node:path";
+const SEVERITY_LABELS = {
+    1: "error",
+    2: "warning",
+    3: "info",
+    4: "hint",
+};
+const SEVERITY_RANK = {
+    1: 0,
+    2: 1,
+    3: 2,
+    4: 3,
+};
+export function formatDiagnostics(filePath, diagnostics, cwd, options = {}) {
+    const normalized = normalizeDiagnostics(diagnostics);
+    if (!normalized.length)
+        return "";
+    const label = cwd ? relative(cwd, filePath) || "." : filePath;
+    const limit = options.max ?? 20;
+    const lines = normalized.slice(0, limit).map((diagnostic) => {
+        const line = (diagnostic.range?.start?.line ?? 0) + 1;
+        const character = (diagnostic.range?.start?.character ?? 0) + 1;
+        const severity = SEVERITY_LABELS[diagnostic.severity ?? 1] ?? "diagnostic";
+        const source = diagnostic.source ? ` ${diagnostic.source}` : "";
+        const code = diagnostic.code === undefined ? "" : ` [${diagnostic.code}]`;
+        return `- ${label}:${line}:${character} ${severity}${source}${code}: ${diagnostic.message}`;
+    });
+    if (normalized.length > lines.length) {
+        lines.push(`- ... ${normalized.length - lines.length} more diagnostic(s)`);
+    }
+    if (options.includeSummary) {
+        lines.unshift(formatDiagnosticSummary(normalized));
+    }
+    return lines.join("\n");
+}
+export function formatDiagnosticBlocks(cwd, currentFile, diagnostics) {
+    let output = "";
+    let otherFiles = 0;
+    for (const [file, issues] of sortDiagnosticEntries(diagnostics, currentFile)) {
+        const normalized = normalizeDiagnostics(issues);
+        if (!normalized.length)
+            continue;
+        if (file === currentFile) {
+            output += `\n\nLSP diagnostics in this file:\n${formatDiagnostics(file, normalized, cwd, { includeSummary: true })}`;
+            continue;
+        }
+        if (otherFiles >= 5)
+            continue;
+        otherFiles += 1;
+        output += `\n\nLSP diagnostics in other files:\n${formatDiagnostics(file, normalized, cwd, { includeSummary: true })}`;
+    }
+    return output;
+}
+export function normalizeDiagnostics(diagnostics) {
+    const byKey = new Map();
+    for (const diagnostic of diagnostics) {
+        const key = [
+            diagnostic.range?.start?.line ?? 0,
+            diagnostic.range?.start?.character ?? 0,
+            diagnostic.severity ?? 1,
+            diagnostic.source ?? "",
+            diagnostic.code ?? "",
+            diagnostic.message,
+        ].join("|");
+        if (!byKey.has(key))
+            byKey.set(key, diagnostic);
+    }
+    return [...byKey.values()].sort(compareDiagnostic);
+}
+export function formatDiagnosticSummary(diagnostics) {
+    const counts = { error: 0, warning: 0, info: 0, hint: 0 };
+    for (const diagnostic of diagnostics) {
+        const label = SEVERITY_LABELS[diagnostic.severity ?? 1] ?? "error";
+        if (label in counts)
+            counts[label] += 1;
+    }
+    const parts = [
+        counts.error ? `${counts.error} error${counts.error === 1 ? "" : "s"}` : "",
+        counts.warning ? `${counts.warning} warning${counts.warning === 1 ? "" : "s"}` : "",
+        counts.info ? `${counts.info} info` : "",
+        counts.hint ? `${counts.hint} hint${counts.hint === 1 ? "" : "s"}` : "",
+    ].filter(Boolean);
+    return parts.length ? `Summary: ${parts.join(", ")}` : "Summary: no diagnostics";
+}
+function sortDiagnosticEntries(diagnostics, currentFile) {
+    return Object.entries(diagnostics).sort(([fileA, issuesA], [fileB, issuesB]) => {
+        if (fileA === currentFile && fileB !== currentFile)
+            return -1;
+        if (fileB === currentFile && fileA !== currentFile)
+            return 1;
+        return strongestSeverity(issuesA) - strongestSeverity(issuesB) || fileA.localeCompare(fileB);
+    });
+}
+function strongestSeverity(diagnostics) {
+    return Math.min(...diagnostics.map((diagnostic) => SEVERITY_RANK[diagnostic.severity ?? 1] ?? 99), 99);
+}
+function compareDiagnostic(a, b) {
+    return (SEVERITY_RANK[a.severity ?? 1] ?? 99) - (SEVERITY_RANK[b.severity ?? 1] ?? 99)
+        || (a.range?.start?.line ?? 0) - (b.range?.start?.line ?? 0)
+        || (a.range?.start?.character ?? 0) - (b.range?.start?.character ?? 0)
+        || (a.source ?? "").localeCompare(b.source ?? "")
+        || a.message.localeCompare(b.message);
+}

package/dist/lsp/index.d.ts

@@ -0,0 +1,3 @@
+export { formatDiagnosticBlocks, formatDiagnosticSummary, formatDiagnostics, normalizeDiagnostics, type FormatDiagnosticsOptions, type LspDiagnostic, } from "./diagnostics.js";
+export { isLspEnabled, isTypeScriptLspEnabled, normalizeLspConfig, type LspConfig, type LspServerConfig, } from "./config.js";
+export { getLspService, TypeScriptLspService, type LspLocationInput, type LspService, type LspStatus, } from "./service.js";

package/dist/lsp/index.js

@@ -0,0 +1,3 @@
+export { formatDiagnosticBlocks, formatDiagnosticSummary, formatDiagnostics, normalizeDiagnostics, } from "./diagnostics.js";
+export { isLspEnabled, isTypeScriptLspEnabled, normalizeLspConfig, } from "./config.js";
+export { getLspService, TypeScriptLspService, } from "./service.js";

package/dist/lsp/service.d.ts

@@ -0,0 +1,97 @@
+import { type LspConfig } from "./config.js";
+import type { LspDiagnostic } from "./diagnostics.js";
+export type LspStatusKind = "starting" | "connected" | "error";
+export interface LspStatus {
+    id: string;
+    name: string;
+    root: string;
+    status: LspStatusKind;
+    message?: string;
+}
+export interface LspLocationInput {
+    file: string;
+    line: number;
+    character: number;
+}
+export interface LspService {
+    onStatusChange(listener: () => void): () => void;
+    isDisabled(): boolean;
+    updateConfig(config?: LspConfig): void;
+    status(): LspStatus[];
+    hasClients(filePath: string): Promise<boolean>;
+    touchFile(filePath: string, diagnostics?: "document" | "full"): Promise<void>;
+    diagnostics(): Record<string, LspDiagnostic[]>;
+    restart(): Promise<void>;
+    hover(input: LspLocationInput): Promise<unknown[]>;
+    definition(input: LspLocationInput): Promise<unknown[]>;
+    references(input: LspLocationInput): Promise<unknown[]>;
+    implementation(input: LspLocationInput): Promise<unknown[]>;
+    documentSymbol(filePath: string): Promise<unknown[]>;
+    workspaceSymbol(query: string): Promise<unknown[]>;
+    prepareCallHierarchy(input: LspLocationInput): Promise<unknown[]>;
+    incomingCalls(input: LspLocationInput): Promise<unknown[]>;
+    outgoingCalls(input: LspLocationInput): Promise<unknown[]>;
+}
+export interface LspTimeouts {
+    initializeMs?: number;
+    requestMs?: number;
+    shutdownMs?: number;
+}
+export declare class ProjectLspService implements LspService {
+    private readonly cwd;
+    private readonly timeouts;
+    private readonly emitter;
+    private readonly clients;
+    private readonly spawning;
+    private readonly initializing;
+    private generation;
+    private readonly starting;
+    private readonly broken;
+    private readonly unavailable;
+    private readonly diagnosticsByFile;
+    private readonly waiters;
+    private disposed;
+    private config;
+    constructor(cwd: string, config?: LspConfig, timeouts?: LspTimeouts);
+    updateConfig(config?: LspConfig): void;
+    restart(): Promise<void>;
+    onStatusChange(listener: () => void): () => void;
+    isDisabled(): boolean;
+    status(): LspStatus[];
+    hasClients(filePath: string): Promise<boolean>;
+    touchFile(filePath: string, diagnostics?: "document" | "full"): Promise<void>;
+    diagnostics(): Record<string, LspDiagnostic[]>;
+    hover(input: LspLocationInput): Promise<unknown[]>;
+    definition(input: LspLocationInput): Promise<unknown[]>;
+    references(input: LspLocationInput): Promise<unknown[]>;
+    implementation(input: LspLocationInput): Promise<unknown[]>;
+    documentSymbol(filePath: string): Promise<unknown[]>;
+    workspaceSymbol(query: string): Promise<unknown[]>;
+    prepareCallHierarchy(input: LspLocationInput): Promise<unknown[]>;
+    incomingCalls(input: LspLocationInput): Promise<unknown[]>;
+    outgoingCalls(input: LspLocationInput): Promise<unknown[]>;
+    shutdown(): Promise<void>;
+    shutdownNow(): void;
+    private runRequest;
+    private callHierarchyRequest;
+    private getClients;
+    private getClient;
+    private spawnClient;
+    private request;
+    private notify;
+    private withDeadline;
+    private stopClient;
+    private openOrChange;
+    private waitForDiagnostics;
+    private resolveDiagnosticWaiters;
+    private matchingServers;
+    private servers;
+    private markBroken;
+    private emitStatus;
+    private resolveInsideCwd;
+    private shutdownClient;
+    private shutdownClients;
+    private shutdownDisabledClients;
+}
+export declare const TypeScriptLspService: typeof ProjectLspService;
+export declare function getLspService(cwd: string, config?: LspConfig): ProjectLspService;