@cerebriline/core 4.100.276 → 4.100.277

package/dist/extensions/diagnostics/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Diagnostics as an editor keeps them, in the shape every host hands over.
+ *
+ * The extension reads them from VS Code (its proto `FileDiagnostics`), the
+ * CLI and automaticum's runner from the language servers they start. The
+ * tools that read them -- `check_file`, the post-edit report -- are shared,
+ * so the shape is core's: a named severity rather than either side's number
+ * (VS Code's proto counts errors from 0, LSP from 1).
+ */
+export type DiagnosticSeverityName = "error" | "warning" | "information" | "hint";
+export interface DiagnosticPosition {
+    /** 0-based, as LSP has it. */
+    line: number;
+    /** 0-based. */
+    character: number;
+}
+export interface HostDiagnostic {
+    message: string;
+    severity: DiagnosticSeverityName;
+    range?: {
+        start?: DiagnosticPosition;
+        end?: DiagnosticPosition;
+    };
+    /** The producer, as the editor names it: "ts", "eslint", "css". */
+    source?: string;
+}
+export interface HostFileDiagnostics {
+    filePath: string;
+    diagnostics: HostDiagnostic[];
+    /**
+     * The file changed after its server last reported on it, so what is held
+     * describes an older text. A reader waiting for the server to settle keeps
+     * waiting while this is set. Hosts that cannot tell leave it out.
+     */
+    pending?: boolean;
+}
+/** Reads every file's current diagnostics. */
+export type ReadDiagnostics = () => Promise<HostFileDiagnostics[]>;
+/**
+ * Hands a server the file as it is on disk now (`save`: as just written), so
+ * its next diagnostics are about that text. The editor does this itself; a
+ * host that starts its own servers has to. Resolves to something truthy when
+ * a server holds the file.
+ */
+export type TouchDocument = (filePath: string, options?: {
+    save?: boolean;
+}) => Promise<unknown>;
+/**
+ * A file's text, as the host reads its disk. Injected where a host wants its
+ * own view -- a sandbox, a test's fake disk -- and defaulted to the real one.
+ */
+export type ReadText = (filePath: string) => Promise<string>;

package/dist/extensions/lsp/lsp-connection.d.ts

@@ -0,0 +1,138 @@
+import type { HostDiagnostic } from "../diagnostics/types";
+export interface LspServerSpec {
+    /** How the server is named in status and errors. Defaults to `command`. */
+    name?: string;
+    /** The executable: a name looked up on PATH, or a full path. */
+    command: string;
+    args: string[];
+    /** Languages this server answers for, as LSP language ids. */
+    languages: string[];
+    /**
+     * The file whose existence says the server is installed. Defaults to
+     * `command` (looked up on PATH when it has no directory in it). A server
+     * started as `node <script>` names its script here.
+     */
+    probe?: string;
+    /** Added to the environment the server starts with. */
+    env?: Record<string, string>;
+    /**
+     * Server-specific `initializationOptions`.
+     *
+     * Needed because a server is not always self-sufficient:
+     * `typescript-language-server` refuses to start unless it can find a
+     * TypeScript installation, and it looks in the workspace. A workspace with
+     * no `node_modules` -- which is most of the ones a model is asked to fix --
+     * gets "Could not find a valid TypeScript installation. Exiting."
+     */
+    initializationOptions?: Record<string, unknown> | (() => Record<string, unknown> | undefined);
+    /**
+     * The settings an editor would hold for this server: sent once with
+     * `workspace/didChangeConfiguration` and read back for every
+     * `workspace/configuration` the server asks. A section nobody set answers
+     * an empty object, never null -- see `LspConnection.setting`.
+     */
+    settings?: Record<string, unknown>;
+    /**
+     * A diagnostic's producer as the editor names it, by what the server
+     * reports: VS Code labels what tsserver reports "ts", where the server
+     * says "typescript".
+     */
+    sources?: Record<string, string>;
+}
+/** The name a spec goes by. */
+export declare function serverName(spec: LspServerSpec): string;
+export declare function fileUri(filePath: string): string;
+export declare function uriToPath(uri: string): string;
+/**
+ * A diagnostic as the editor keeps it, from what a server sent: a position,
+ * a named severity, the message and the producer. LSP leaves the severity
+ * to the client when it is absent; VS Code treats that as an error.
+ */
+export declare function normalizeLspDiagnostic(raw: unknown): HostDiagnostic;
+export interface LspConnectionOptions {
+    onError?: (message: string, error: unknown) => void;
+    /** Every `textDocument/publishDiagnostics`, the path decoded. */
+    onDiagnostics?: (filePath: string, diagnostics: HostDiagnostic[]) => void;
+}
+/**
+ * One server process and the conversation with it.
+ *
+ * Requests are correlated by id. A message with a `method` is the server's,
+ * whether or not it has an id: with one it is a request and is answered, and
+ * only a message without a `method` is a response to one of ours. A server
+ * that dies takes its pending requests with it rather than leaving them
+ * hanging until the timeout.
+ */
+export declare class LspConnection {
+    readonly spec: LspServerSpec;
+    private readonly rootPath;
+    private child;
+    private buffer;
+    private nextId;
+    private readonly pending;
+    /** What the server holds open, by URI: the text it was last sent. */
+    private readonly documents;
+    private initializing;
+    private failure;
+    private pullRefused;
+    /** What the server said it can do, from its `initialize` answer. */
+    capabilities: Record<string, unknown>;
+    private readonly onError?;
+    private readonly onDiagnostics?;
+    constructor(spec: LspServerSpec, rootPath: string, options?: LspConnectionOptions | ((message: string, error: unknown) => void));
+    /** Whether the server has been started and is still running. */
+    get started(): boolean;
+    /** Why the server is not available, once it has failed. */
+    get failed(): Error | undefined;
+    /** Started once, on the first question, and shared by every one after it. */
+    ready(): Promise<void>;
+    private start;
+    private fail;
+    private consume;
+    private dispatch;
+    /**
+     * A request of the server's own, answered as an editor answers it.
+     *
+     * Left unanswered, some servers wait for the answer before doing anything
+     * else.
+     */
+    private answer;
+    /**
+     * A section of the settings, as an editor answers: an object, empty for a
+     * section nobody set. Never null: the CSS validator reads properties off
+     * what it is given ("Cannot read properties of null (reading
+     * 'validProperties')"), and the HTML server validates a page's `<style>`
+     * through it, so a null aborts the whole page's validation -- and a page
+     * whose script does not parse then reports no diagnostics at all.
+     */
+    setting(section: string | undefined): unknown;
+    private send;
+    notify(method: string, params: unknown): void;
+    request(method: string, params: unknown, timeoutMs?: number): Promise<unknown>;
+    /**
+     * Make the server hold the file as it is now.
+     *
+     * Opened the first time; after that, sent whole as a change, with the next
+     * version, when it differs from what the server holds. A second `didOpen`
+     * for a document already open is a protocol error that servers answer by
+     * ignoring it -- and then answering from the old text, which is exactly
+     * the "the model edits, then asks" case. Returns whether the server was
+     * told anything.
+     */
+    syncDocument(filePath: string, text: string, languageId: string): boolean;
+    /**
+     * Tell the server the file was written. Some servers check only on save:
+     * rust-analyzer's type errors come from `cargo check` on `didSave`.
+     */
+    documentSaved(filePath: string): void;
+    /** Whether this server answers `textDocument/diagnostic` when asked. */
+    get pullsDiagnostics(): boolean;
+    /**
+     * Diagnostics asked for, from a server that answers only when asked
+     * (csharp-ls). Undefined when the server does not pull, or answered with
+     * something other than a full report.
+     */
+    pullDiagnostics(filePath: string): Promise<HostDiagnostic[] | undefined>;
+    private label;
+    dispose(): Promise<void>;
+}

package/dist/extensions/lsp/lsp-host.d.ts

@@ -0,0 +1,134 @@
+import type { HostFileDiagnostics } from "../diagnostics/types";
+import type { CodeIntelProvider } from "../tools/ask-lsp";
+import { type LspServerSpec } from "./lsp-connection";
+/**
+ * The language servers of a host that has no editor to ask.
+ *
+ * In the extension, `ask_lsp`, `check_file` and the post-edit report read VS
+ * Code, which already runs a server for every language in the workspace. A
+ * terminal runs none, so this resolves a server per language, starts it on
+ * the first question about a file of it, keeps it for the session, and keeps
+ * what it publishes as the editor keeps it.
+ *
+ * The tools' contract is what makes this tractable: an operation that cannot
+ * be answered returns nothing, and the tool says so plainly. So a language
+ * with no server installed is a quiet "no answer" rather than an error -- the
+ * same outcome the extension produces for a language whose extension the user
+ * never installed.
+ */
+/** LSP language ids, by the extension that implies them. */
+export declare const LANGUAGE_BY_EXTENSION: Readonly<Record<string, string>>;
+export declare function languageIdFor(filePath: string): string | undefined;
+/**
+ * A TypeScript installation this machine already has, for servers that need one.
+ *
+ * Only the globally installed one is considered: a workspace that has its own
+ * is found by the server without help, and this exists for the case where there
+ * is nothing to find. `tsserver.js` rather than the package root, because the
+ * 7.x `typescript` package is a native wrapper that ships no `tsserver` at all
+ * and would otherwise be handed over as if it were usable.
+ */
+export declare function findGlobalTypescriptLib(): string | undefined;
+/**
+ * What VS Code's HTML extension hands its server, and what it answers when
+ * the server asks: the script and the style of a page are checked as
+ * JavaScript and CSS. The server's script mode reads
+ * `js/ts.implicitProjectConfig` with no guard, so it is given VS Code's
+ * defaults rather than left to fail.
+ */
+export declare const HTML_SERVER_SETTINGS: Record<string, unknown>;
+/**
+ * The servers this host will try, and what each one answers for.
+ *
+ * Resolution is by what is actually on the machine: the first spec whose
+ * command exists and whose language list covers the file wins. Nothing is
+ * installed on demand -- a host that pulled down a language server mid-turn
+ * would be a surprise, and the tools degrade honestly without one. A host
+ * with its own install prefix (automaticum's runner) passes its own specs.
+ */
+export declare const DEFAULT_LSP_SERVERS: LspServerSpec[];
+/**
+ * Whether a command can be run, without running it.
+ *
+ * A PATH walk rather than `which`: spawning a shell to ask about ten servers
+ * costs more than reading ten directories, and this runs before the first
+ * question is answered.
+ */
+export declare function commandExists(command: string): boolean;
+/** Whether a spec's server is on this machine. */
+export declare function isServerInstalled(spec: LspServerSpec): boolean;
+export interface HtmlServerTypescriptGap {
+    /** Where the server reads TypeScript's `lib.*.d.ts` from. */
+    expected: string;
+    /** A TypeScript beside the server that would fill it, if there is one. */
+    typescript?: string;
+}
+/**
+ * Whether the HTML server of `vscode-langservers-extracted` will find
+ * TypeScript's library files.
+ *
+ * Its bundle (4.10.0) computes them as `<prefix>/node_modules/node_modules/
+ * typescript/lib` -- one `node_modules` too many -- so in a normal install
+ * they are never there, and a page's script is checked with no types: hover
+ * says `any`. Nothing the client sends changes the path. Returns the gap, or
+ * nothing when the server is not that one or the files are there.
+ */
+export declare function findHtmlServerTypescriptGap(spec: LspServerSpec): HtmlServerTypescriptGap | undefined;
+/**
+ * Fill the gap with a link to the TypeScript beside the server.
+ *
+ * Writes into the server's install prefix, so it is never done implicitly: a
+ * host calls this when its owner has said so (automaticum's image does the
+ * same at build time). Returns whether the link now exists.
+ */
+export declare function repairHtmlServerTypescript(gap: HtmlServerTypescriptGap): boolean;
+/** The languages of a workspace's files, looked for at most `limit` entries deep. */
+export declare function workspaceLanguages(root: string, limit?: number): string[];
+export interface LspServerStatus {
+    server: string;
+    languages: string[];
+    installed: boolean;
+    started?: boolean;
+    failed?: string;
+    /** Something the server needs that this machine lacks. */
+    warning?: string;
+}
+export interface LspHostOptions {
+    /** The workspace root the servers start in. */
+    cwd: string;
+    /** Tried in order; the first installed one for a language wins. */
+    servers?: LspServerSpec[];
+    onError?: (message: string, error: unknown) => void;
+    /** Whether a spec's server is installed. Defaults to a PATH/probe check. */
+    isInstalled?: (spec: LspServerSpec) => boolean;
+}
+export interface LspHost {
+    /** `ask_lsp`'s host half. */
+    provider: CodeIntelProvider;
+    /**
+     * Hand the file's server the file as it is on disk (`save`: as just
+     * written). Undefined when no server answers for it or it cannot be read.
+     */
+    touch(filePath: string, options?: {
+        save?: boolean;
+    }): Promise<{
+        languageId: string;
+    } | undefined>;
+    /** Whether an installed server answers for this file's language. */
+    serves(filePath: string): boolean;
+    /**
+     * Every file a server has reported on, with `pending` set when the file
+     * changed after the server last reported on it.
+     */
+    readDiagnostics(): Promise<HostFileDiagnostics[]>;
+    /** Start the servers for these languages (default: the workspace's) now. */
+    prewarm(languages?: string[]): string[];
+    /** Which server answers for which language, and in what state. */
+    status(): LspServerStatus[];
+    dispose(): Promise<void>;
+}
+/**
+ * The session's language servers, behind `ask_lsp`, `check_file` and the
+ * post-edit report.
+ */
+export declare function createLspHost(options: LspHostOptions): LspHost;

package/dist/extensions/tools/schemas.d.ts

@@ -27,7 +27,7 @@ export declare const ReadFileRequestSchema: z.ZodObject<{
     path: z.ZodString;
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
 }, z.core.$strip>;
 /**
  * Schema for read_files tool input
@@ -37,7 +37,7 @@ export declare const ReadFilesInputSchema: z.ZodObject<{
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
@@ -48,13 +48,13 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
     path: z.ZodString;
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
 }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -83,7 +83,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
     path: z.ZodString;
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
 }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
     start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -113,7 +113,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -144,7 +144,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -181,7 +181,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -212,7 +212,7 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
         path: z.ZodString;
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+        line_numbers: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
         start_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         end_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
@@ -649,7 +649,7 @@ export declare const EditFileInputSchema: z.ZodObject<{
     end_column: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     insert_column: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     occurrence: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    replace_all: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    replace_all: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
 }, z.core.$strip>;
 /**
  * The editor's arguments as the model is shown them and writes them.
@@ -671,7 +671,7 @@ export declare const EditorToolInputSchema: z.ZodObject<{
     end_column: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     insert_line: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     insert_column: z.ZodOptional<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    replace_all: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean>>>;
+    replace_all: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
     file_path: z.ZodString;
 }, z.core.$strip>;
 export type EditorToolInput = z.infer<typeof EditorToolInputSchema>;
@@ -820,7 +820,7 @@ export declare const GrepInputUnionSchema: z.ZodPreprocess<z.ZodObject<{
     context: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     max_count: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     paths: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>]>>;
-}, z.core.$strip>>;
+}, z.core.$strip>, unknown>;
 export declare const SedInputUnionSchema: z.ZodObject<{
     script: z.ZodString;
     in_place: z.ZodOptional<z.ZodBoolean>;

package/dist/extensions/tools/transform-image.d.ts

@@ -94,6 +94,17 @@ export interface TransformSpec {
     /** Painted under the image, over the whole result. */
     background?: string;
 }
+/**
+ * `planTransform`'s text, for the page to run.
+ *
+ * Bound to the name in the page (`var planTransform = (...)`) rather than
+ * pasted as a declaration: a minified build renames the function -- the
+ * published 4.100.276 bundle has it as `function BK(...)` -- and a page that
+ * then calls `planTransform(...)` throws "planTransform is not defined",
+ * draws nothing, and every `transform_image` call reports a valid image as
+ * unreadable. As an expression its own name no longer matters.
+ */
+export declare function planTransformSource(): string;
 /** The page that draws one image at its new size. */
 export declare function buildTransformDocument(sourceUrl: string, spec: TransformSpec): string;
 /** One image, drawn at a new size by the host's browser. */