dsh-vscode-workbench 0.1.14 → 0.2.0

package/lib/types/client/MonacoEditor.d.ts

@@ -1,3 +1,4 @@
+import type { EditorSelection } from './dshComposer.ts';
 type Monaco = typeof import('monaco-editor');
 declare global {
     interface Window {
@@ -10,17 +11,44 @@ declare global {
 }
 /** Monaco chrome used by both editors so only the narrow native scrollbar remains. */
 export declare const WORKBENCH_EDITOR_CHROME: {
+    readonly definitionLinkOpensInPeek: false;
+    readonly gotoLocation: {
+        readonly multipleDefinitions: "gotoAndPeek";
+        readonly multipleReferences: "peek";
+        readonly multipleImplementations: "peek";
+        readonly multipleTypeDefinitions: "gotoAndPeek";
+        readonly multipleDeclarations: "peek";
+        readonly alternativeDefinitionCommand: "editor.action.goToReferences";
+    };
+    readonly parameterHints: {
+        readonly enabled: true;
+        readonly cycle: true;
+    };
+    readonly quickSuggestions: {
+        readonly other: true;
+        readonly comments: false;
+        readonly strings: false;
+    };
+    readonly suggestOnTriggerCharacters: true;
     readonly minimap: {
         readonly enabled: false;
     };
     readonly renderOverviewRuler: false;
     readonly overviewRulerLanes: 0;
     readonly hideCursorInOverviewRuler: true;
+    readonly renderLineHighlightOnlyWhenFocus: true;
     readonly scrollbar: {
         readonly verticalScrollbarSize: 10;
         readonly horizontalScrollbarSize: 10;
     };
 };
+/** Monaco theme aligned with the workbench dark palette. */
+export declare const DARK_THEME = "dvw-dark";
+/**
+ * Bootstrap source for Monaco's AMD web workers. Workers resolve module paths against their own
+ * blob URL, so they need an absolute `baseUrl`; without it the TypeScript language worker fails to load.
+ */
+export declare function monacoWorkerBootstrap(base: string): string;
 export declare function loadMonaco(): Promise<Monaco>;
 export declare function MonacoDiffEditor(props: {
     uri: string;
@@ -28,14 +56,22 @@ export declare function MonacoDiffEditor(props: {
     modified: string;
     mode: 'inline' | 'split';
     theme: 'dark' | 'light';
+    fontSize?: number;
 }): import("react").JSX.Element;
+/** Start downloading Monaco in the background so the first opened file does not wait for it. */
+export declare function preloadMonaco(): void;
+/** Dispose the models of closed tabs so Monaco stops tracking their text. */
+export declare function retainEditorModels(uris: string[]): void;
 export declare function MonacoEditor(props: {
     uri: string;
     value: string;
     theme: 'dark' | 'light';
     line?: number;
     column?: number;
+    fontSize?: number;
+    highlight?: string;
     onChange(value: string): void;
     onSave(): void;
+    onAddToDsh?(selection?: EditorSelection): void;
 }): import("react").JSX.Element;
 export {};

package/lib/types/client/Workbench.d.ts

@@ -1,5 +1,6 @@
 import type { FileDocument, GitCommit, GitDiff } from '../types.ts';
 import type { VscodeWorkbench } from './service.ts';
+import type { DshNavigation } from './dshNavigation.ts';
 import { type DocumentPreviewKind } from './documentPreview.tsx';
 interface Tab extends FileDocument {
     instance?: symbol;
@@ -8,6 +9,7 @@ interface Tab extends FileDocument {
     loaded?: boolean;
     line?: number;
     column?: number;
+    highlight?: string;
     external?: boolean;
     preview?: boolean;
     title?: string;
@@ -21,8 +23,6 @@ interface Tab extends FileDocument {
 type ResizeDirection = 1 | -1;
 /** Calculate a panel width from a horizontal pointer movement. */
 export declare function resizedPanelWidth(startWidth: number, startX: number, nextX: number, direction: ResizeDirection, min: number, max: number): number;
-/** Retry a workspace lookup that raced the Host publishing its session after startup. */
-export declare function workspaceRetryDelay(error: unknown, attempt: number): number | undefined;
 /** Restore tab headers without reading their file contents. */
 export declare function restoreTabPaths(paths: string[]): Tab[];
 /** Return whether file changes require reloading one visible directory. */
@@ -37,10 +37,22 @@ export declare function tabScrollLeft(scrollLeft: number, viewport: {
     left: number;
     right: number;
 }): number;
+/** Workspace-relative directory that would contain `path`. */
+export declare function parentPath(path: string): string;
+/** Destination path when moving an entry into `directory`. */
+export declare function movedPath(path: string, directory: string): string;
+/** Reject moves into the same folder, into the entry itself, or into its descendants. */
+export declare function canMoveTo(path: string, directory: string): boolean;
+/** Chromium `DownloadURL` payload that lets a file be dropped onto the desktop or another app. */
+export declare function downloadUrlData(sessionId: string, path: string, origin: string): string;
 /** Return the workspace-relative directory used by the file picker. */
 export declare function uploadDestination(selectedDirectory?: string): string;
 /** Join an inline-created entry name to the currently selected Explorer directory. */
 export declare function createdEntryPath(directory: string, name: string): string;
+/** Git prints many PDFs and archives as a text patch, so classify binary diffs by extension instead. */
+export declare function isBinaryDiffPath(path: string): boolean;
+/** Files the workbench can show as a document or image preview, which Git changes should open directly. */
+export declare function isPreviewDocumentPath(path: string): boolean;
 /** Replace the final path component while preserving its workspace-relative directory. */
 export declare function renamedPath(path: string, name: string): string;
 export interface GraphTrack {
@@ -55,14 +67,14 @@ export interface GraphRow {
     parentLanes: number[];
 }
 export declare function graphRows(commits: GitCommit[]): GraphRow[];
-/** Draw a fixed-radius, orthogonal transition between two graph lanes. */
+/** Move a passing lane to its new column with two 5px arcs around the row midline. */
 export declare function graphTrackPath(from: number, to: number, startY: number, endY: number, bendY: number): string;
-export declare function Launcher({ service }: {
-    service: VscodeWorkbench;
-}): import("react").JSX.Element;
-export declare function Workbench({ service, sessionId, cwd }: {
+/** Leave the node horizontally and turn down into a parent lane with a lane-width arc. */
+export declare function graphParentPath(from: number, to: number, midY: number, endY: number): string;
+export declare function Workbench({ service, sessionId, cwd, navigation }: {
     service: VscodeWorkbench;
     sessionId?: string;
     cwd?: string;
+    navigation?: DshNavigation;
 }): import("react").JSX.Element | null;
 export {};

package/lib/types/client/WorkspaceSwitcher.d.ts

@@ -0,0 +1,13 @@
+import type { WorkspaceChoice } from './dshNavigation.ts';
+/** Centered switcher: existing workspaces, their sessions, and a new-workspace action. */
+export declare function WorkspaceSwitcher({ choices, activeSessionId, unavailable, busy, error, onCreate, onSwitch, onOpenWorkspace, onClose }: {
+    choices: WorkspaceChoice[];
+    activeSessionId?: string;
+    unavailable: boolean;
+    busy: boolean;
+    error?: string;
+    onCreate(): void;
+    onSwitch(sessionId: string): void;
+    onOpenWorkspace(workspaceId: string): void;
+    onClose(): void;
+}): import("react").JSX.Element;

package/lib/types/client/api.d.ts

@@ -2,4 +2,6 @@ export declare class ApiError extends Error {
     code: string;
     constructor(code: string, message: string);
 }
+/** Back off while DSH publishes the current session after startup; every view shares this retry. */
+export declare function sessionRetryDelay(error: unknown, attempt: number): number | undefined;
 export declare function api<T>(method: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<T>;

package/lib/types/client/documentPreview.d.ts

@@ -1,11 +1,19 @@
-export type DocumentPreviewKind = 'pdf' | 'docx' | 'download';
+type XlsxModule = typeof import('xlsx');
+/** Load SheetJS from the host-hosted browser build; bundling it drags Node builtins into the client. */
+export declare function loadXlsx(): Promise<XlsxModule>;
+export type DocumentPreviewKind = 'pdf' | 'office' | 'sheet' | 'download';
 /** Bound PDF zoom to values that remain usable in the workbench viewport. */
 export declare function clampPdfScale(scale: number): number;
 /** Return the in-workbench preview supported for a document path. */
 export declare function documentPreviewKind(path: string): DocumentPreviewKind | undefined;
-/** Render an in-workbench preview for PDF and Word documents. */
+/** Convert one worksheet matrix into display rows, keeping large books responsive. */
+export declare function sheetTable(rows: readonly unknown[][], limits?: {
+    rows: number;
+    columns: number;
+}): string[][];
 export declare function DocumentPreview({ kind, src, path }: {
     kind: DocumentPreviewKind;
     src: string;
     path: string;
 }): import("react").JSX.Element;
+export {};

package/lib/types/client/dshComposer.d.ts

@@ -0,0 +1,21 @@
+/** Selected editor text, with 1-based inclusive line numbers. */
+export interface EditorSelection {
+    text: string;
+    startLine: number;
+    endLine: number;
+}
+/** Explorer and editor shortcut that adds the current file or selection to the DSH chat. */
+export declare const ADD_TO_DSH_SHORTCUT = "Ctrl+Alt+K";
+/** True for the add-to-DSH chord; Monaco binds it separately, so this covers the Explorer. */
+export declare function isAddToDshShortcut(event: Pick<KeyboardEvent, 'ctrlKey' | 'metaKey' | 'altKey' | 'shiftKey' | 'code' | 'isComposing'>): boolean;
+/** Workspace-relative reference the agent can read: `path`, `dir/`, or `path:start-end` plus a fenced copy of the selection. */
+export declare function dshReference(path: string, options?: {
+    directory?: boolean;
+    selection?: EditorSelection;
+}): string;
+/** Separator that keeps an inserted reference from gluing onto the existing draft. */
+export declare function referenceSeparator(draft: string, reference: string): string;
+/** The DSH composer input, preferring the copy shown in the workbench's right column. */
+export declare function findDshComposer(documentRoot?: Document): HTMLElement | null;
+/** Append `reference` to the DSH draft through native editing so DSH's input machine and undo stack see it. */
+export declare function insertIntoDshComposer(reference: string, documentRoot?: Document): Promise<boolean>;

package/lib/types/client/dshNavigation.d.ts

@@ -0,0 +1,46 @@
+/** Access to DSH's client-side workspace and session stores for the in-workbench switcher. */
+export interface WorkspaceChoice {
+    id: string;
+    title: string;
+    path: string;
+    sessions: SessionChoice[];
+}
+export interface SessionChoice {
+    id: string;
+    title: string;
+    blank: boolean;
+    active: boolean;
+}
+interface SessionSummary {
+    title?: string;
+    blank?: boolean;
+    projectionValues?: {
+        title?: string;
+    };
+}
+interface WorkspacesSnapshot {
+    items?: readonly {
+        workspaceId: string;
+        title: string;
+        path: string;
+        sessionIds: readonly string[];
+    }[];
+    phase?: string;
+}
+interface SessionsSnapshot {
+    ids: readonly string[];
+    byId: Record<string, SessionSummary>;
+    phase?: string;
+}
+/** The slice of DSH's client context the switcher needs, read through `ctx.get` like ui-conversation does. */
+export interface DshNavigation {
+    available: boolean;
+    choices(activeSessionId?: string): WorkspaceChoice[];
+    openSession(id: string): boolean;
+    openWorkspace(id: string): boolean;
+}
+/** Build display rows from the two snapshot stores, keeping DSH's own workspace and session order. */
+export declare function buildWorkspaceChoices(workspaces: WorkspacesSnapshot | undefined, sessions: SessionsSnapshot | undefined, activeSessionId?: string): WorkspaceChoice[];
+/** Resolve the DSH client services; `get` returns undefined outside the web/desktop client. */
+export declare function createDshNavigation(get: ((name: string) => unknown) | undefined): DshNavigation;
+export {};

package/lib/types/client/fileIconMap.d.ts

@@ -0,0 +1,2 @@
+/** Resolve the vscode-icons asset name for a tree entry or tab. */
+export declare function fileIconName(name: string, directory: boolean, expanded: boolean): string;

package/lib/types/client/gitError.d.ts

@@ -0,0 +1,2 @@
+/** Normalize a Git/API error into the sentence shown in the branch-switch dialog. */
+export declare function branchErrorMessage(error: unknown): string;

package/lib/types/client/lsp.d.ts

@@ -0,0 +1,27 @@
+type Monaco = typeof import('monaco-editor');
+/** One language server as reported by the host catalog. */
+export interface LspServerStatus {
+    id: string;
+    name: string;
+    languages: string[];
+    installable: boolean;
+    installed: boolean;
+    hint?: string;
+}
+/** Normalize definition/reference payloads (Location, LocationLink or arrays) into Monaco locations. */
+export declare function lspLocations(monaco: Monaco, result: unknown): import('monaco-editor').languages.Location[];
+export declare class LspManager {
+    private readonly monaco;
+    private readonly sessionId;
+    private readonly workspaceRoot;
+    private connections;
+    private failures;
+    constructor(monaco: Monaco, sessionId: string, workspaceRoot: string);
+    /** Start servers that are installed and not already running; stop any that were uninstalled. */
+    sync(servers: LspServerStatus[]): Promise<string[]>;
+    stop(id: string): void;
+    dispose(): void;
+}
+/** Language server that handles a workspace path, derived from its extension or well-known filename. */
+export declare function languageServerIdForPath(path: string): string | undefined;
+export {};

package/lib/types/client/searchHighlight.d.ts

@@ -0,0 +1,5 @@
+/** Selection range for a search hit on one line, falling back to the reported column. */
+export declare function searchHighlightRange(lineText: string, needle: string, column: number): {
+    startColumn: number;
+    endColumn: number;
+};

package/lib/types/client/typescriptProject.d.ts

@@ -0,0 +1,20 @@
+type Monaco = typeof import('monaco-editor');
+/** Settings key for the TS/JS language support; nothing is indexed until the user installs it in settings. */
+export declare const TS_INTELLISENSE_KEY = "dvw:lsp:typescript";
+export declare function tsIntellisenseEnabled(): boolean;
+/** Model URI for a workspace file; must match MonacoEditor's `file:///<cwd>/<path>` tab URIs. */
+export declare function projectModelPath(cwd: string, path: string): string;
+/** Workspace-relative path for a project model URI, or undefined when it lives outside `cwd`. */
+export declare function workspacePathFromModel(cwd: string, uri: string): string | undefined;
+/** Configure Monaco's TypeScript worker and load the workspace's TS/JS files so definitions, references, Peek and signature help resolve across files. */
+export declare function indexTypeScriptProject(monaco: Monaco, sessionId: string, cwd: string): Promise<{
+    files: number;
+    truncated: boolean;
+}>;
+/** Drop the index models that no editor or tab is using. */
+export declare function disposeTypeScriptProject(monaco: Monaco): void;
+/** True for models the project index created, which tab cleanup must keep. */
+export declare function isIndexedModel(uri: string): boolean;
+/** Refresh index models for files changed on disk, unless an editor is showing them. */
+export declare function refreshIndexedFiles(monaco: Monaco, sessionId: string, cwd: string, paths: string[]): Promise<void>;
+export {};

package/lib/types/context.d.ts

@@ -19,6 +19,21 @@ export interface WorkbenchSessions {
 export interface WorkbenchConnection {
     requestRejection(req: IncomingMessage): 401 | 403 | undefined;
 }
+/** Minimal shape of DSH's host directory chooser; only the native capability is usable here. */
+export interface DirectoryPickerLike {
+    capability(): {
+        kind: string;
+        pick?(signal: AbortSignal): Promise<string | null>;
+    };
+}
+/** Minimal shape of DSH's durable workspace registry. */
+export interface WorkspaceRegistryLike {
+    create(path: string, title?: string): Promise<{
+        id: string;
+        path: string;
+        title: string;
+    }>;
+}
 export type HostContext = CordisContext & {
     webServer: WorkbenchWebServer;
     sessions: WorkbenchSessions;

package/lib/types/host.d.ts

@@ -6,6 +6,27 @@ export declare function workspacePath(cwd: string, raw: string, create?: boolean
     root: string;
     absolute: string;
 }>;
+/** Add a folder picked in the OS chooser to DSH's workspace list, reusing an existing registration. */
+export declare function openWorkspaceFromPicker(picker: import('./context.ts').DirectoryPickerLike | undefined, registry: import('./context.ts').WorkspaceRegistryLike | undefined, signal: AbortSignal): Promise<{
+    opened: boolean;
+    workspace?: {
+        id: string;
+        path: string;
+        title: string;
+    };
+}>;
+/** TS/JS sources the editor's language service indexes, bounded so huge repos stay responsive. */
+export declare function projectSources(cwd: string, limits?: {
+    files?: number;
+    bytes?: number;
+    fileBytes?: number;
+}): Promise<{
+    files: {
+        path: string;
+        content: string;
+    }[];
+    truncated: boolean;
+}>;
 export declare function listFiles(cwd: string, path: string): Promise<FileEntry[]>;
 export declare function readDocument(cwd: string, path: string): Promise<FileDocument>;
 export declare function saveDocument(cwd: string, path: string, content: string, expected: string): Promise<FileDocument>;
@@ -24,6 +45,12 @@ export declare function workspacePreviewFile(cwd: string, path: string): Promise
     path: string;
     type: string;
 }>;
+/** Resolve a regular workspace file for drag-out downloads. */
+export declare function workspaceDownloadFile(cwd: string, path: string): Promise<{
+    path: string;
+    name: string;
+    size: number;
+}>;
 /** Resolve the PDF.js worker shipped with this plugin's runtime dependency. */
 export declare function pdfWorkerAsset(): {
     path: string;
@@ -46,8 +73,18 @@ export declare function codiconAsset(): {
     path: string;
     type: string;
 };
+/** Browser build of SheetJS served as an asset so the client bundle stays free of Node builtins. */
+export declare function xlsxAsset(): {
+    path: string;
+    type: string;
+};
 export declare function monacoAsset(raw: string): {
     path: string;
     type: string;
 };
+/** Resolve a vscode-icons SVG shipped by @vscode-icons/vscode-icons-api. */
+export declare function fileIconAsset(raw: string): {
+    path: string;
+    type: string;
+};
 export {};

package/lib/types/lsp.d.ts

@@ -0,0 +1,54 @@
+/** Host-side registry and process bridge for language servers exposed to the workbench editor. */
+import { type ChildProcess } from 'node:child_process';
+export type LspInstall = {
+    kind: 'npm';
+    package: string;
+    bin: string;
+} | {
+    kind: 'system';
+    command: string;
+    hint: string;
+};
+export interface LspDefinition {
+    id: string;
+    name: string;
+    /** Monaco language ids this server answers for. */
+    languages: string[];
+    install: LspInstall;
+    args: string[];
+}
+/** The strongest maintained server for each language, installable where the ecosystem allows it. */
+export declare const LSP_SERVERS: readonly LspDefinition[];
+export interface LspStatus {
+    id: string;
+    name: string;
+    languages: string[];
+    installable: boolean;
+    installed: boolean;
+    hint?: string;
+}
+/** Private install root so language servers never touch the user's global npm state. */
+export declare function lspRoot(): string;
+export declare function lspStatuses(): Promise<LspStatus[]>;
+/** Install an npm-distributed server into the plugin's private directory. */
+export declare function installLsp(id: string): Promise<void>;
+export declare function uninstallLsp(id: string): Promise<void>;
+/** Resolve the spawn command for a running server, or explain what the user must install. */
+export declare function resolveLsp(id: string): Promise<{
+    command: string;
+    shell: boolean;
+    args: string[];
+}>;
+/** Serialize a JSON-RPC message using the Language Server Protocol base framing. */
+export declare function frameLsp(message: unknown): string;
+/** Incremental decoder for LSP frames arriving in arbitrary chunks. */
+export declare function lspFrameParser(onMessage: (message: unknown) => void): (chunk: Buffer) => void;
+/** Wire a spawned language server's stdio to JSON-RPC frames in both directions. */
+export declare function pipeLanguageServer(child: ChildProcess, handlers: {
+    onMessage(message: unknown): void;
+    onStderr?(text: string): void;
+    onExit?(code: number | null): void;
+}): {
+    write(text: string): void;
+    kill(): void;
+};

package/lib/types/office.d.ts

@@ -0,0 +1,17 @@
+/** True for extensions the Office preview routes through a PDF conversion. */
+export declare function isOfficeDocumentPath(path: string): boolean;
+/** Whether a path is a document that can only be shown through the converter. */
+export declare function needsOfficeConversion(path: string): boolean;
+/** Install guidance mirrors DSH: the preview never downloads an engine itself. */
+export declare const OFFICE_HINT = "\u672A\u68C0\u6D4B\u5230 LibreOffice\u3002\u5B89\u88C5 LibreOffice \u540E\u53EF\u50CF DSH \u5B98\u65B9\u9884\u89C8\u4E00\u6837\u628A Word / PowerPoint \u8F6C\u6210 PDF \u67E5\u770B\u3002";
+/** Locate LibreOffice without repeatedly probing the system for every open tab. */
+export declare function findOfficeConverter(): Promise<string | undefined>;
+/** Availability payload for the settings and preview UI. */
+export declare function officeStatus(): Promise<{
+    available: boolean;
+    hint?: string;
+}>;
+/** Convert one workspace document to a cached PDF and return its absolute path. */
+export declare function officePdf(cwd: string, path: string): Promise<{
+    path: string;
+}>;

package/lib/types/types.d.ts

@@ -41,6 +41,11 @@ export interface GitChange {
     staged: boolean;
     untracked: boolean;
 }
+/** One local branch and the linked worktree that has it checked out. */
+export interface GitBranch {
+    name: string;
+    worktree?: string;
+}
 /** Local repository state. */
 export interface GitStatus {
     repository: string;

package/lib/types/watch-ignore.d.ts

@@ -4,5 +4,9 @@ export declare const DEFAULT_WATCH_IGNORES: readonly [".git", ".hg", ".svn", "no
 export declare function parseWatchIgnores(value: string | null | undefined): string[];
 /** Return true when a workspace-relative path contains one of the excluded segment sequences. */
 export declare function isIgnoredPath(relativePath: string, patterns: readonly string[]): boolean;
+/** Literal directory/path rules from a .gitignore; glob and negation rules are left to git itself. */
+export declare function parseGitIgnore(text: string): string[];
+/** Ignore patterns derived from the workspace's root .gitignore, without asking the user to type exclusions. */
+export declare function workspaceWatchIgnores(workspace: string): Promise<string[]>;
 /** Build a chokidar `ignored` predicate for one workspace and the user's extra exclusions. */
 export declare function watchIgnore(workspace: string, extra: readonly string[]): (path: string) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vscode-workbench",
-  "version": "0.1.14",
+  "version": "0.2.0",
   "description": "Explorer, Monaco editor, search and local Git overlay for DSH",
   "type": "module",
   "license": "MIT",
@@ -56,6 +56,7 @@
     }
   },
   "dependencies": {
+    "@vscode-icons/vscode-icons-api": "^1.0.4",
     "@vscode/codicons": "^0.0.36",
     "@vscode/ripgrep": "^1.15.14",
     "@xterm/addon-fit": "^0.11.0",
@@ -67,7 +68,9 @@
     "monaco-editor": "^0.52.2",
     "node-pty": "^1.1.0",
     "pdfjs-dist": "4.10.38",
-    "ws": "^8.18.0"
+    "vscode-icons-js": "^11.6.1",
+    "ws": "^8.18.0",
+    "xlsx": "0.18.5"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5",