dsh-openwrite 0.2.8

package/packages/studio-panel/lib/types/client/TurnMutationSummary.d.ts

@@ -0,0 +1,62 @@
+import type { ConversationNodeDefinition } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { StudioApiInjected } from './api.ts';
+export interface NovelMutationItem {
+    callId: string;
+    tool: string;
+    label: string;
+    path: string;
+    status: 'succeeded' | 'partial' | 'failed' | 'refresh_failed' | 'proposed' | 'rejected';
+    errorCode: string;
+    historyVersionId: string;
+    revision: string;
+    sourceRevision: string;
+    resultRevision: string;
+    changes: readonly NovelEntityChange[];
+    previewToken: string;
+    undoPreviewToken: string;
+    traceId?: string;
+    tracePath?: string;
+    modelCallCount?: number;
+    traceRetentionDays?: number;
+}
+export interface NovelMutationValue {
+    kind: 'missing' | 'text' | 'boolean' | 'number' | 'null' | 'list' | 'object';
+    value: unknown;
+    preview: string;
+    truncated: boolean;
+    units: number;
+    sha256: string;
+}
+export interface NovelEntityChange {
+    changeId: string;
+    entityKind: string;
+    entityId: string;
+    path: string;
+    field: string;
+    before: NovelMutationValue;
+    after: NovelMutationValue;
+    sourceRevision: string;
+    resultRevision: string;
+    executionStatus: string;
+}
+export interface NovelMutationSummary {
+    items: readonly NovelMutationItem[];
+}
+interface MutationState {
+    turn: number;
+    calls: Readonly<Record<string, NovelMutationItem>>;
+    items: readonly NovelMutationItem[];
+}
+declare module '@deepseek-ai/dsh-client-ui-conversation/client' {
+    interface ConversationTurnDataMap {
+        'dsh-novel-mutations': NovelMutationSummary;
+    }
+}
+/** State-only durable event definition feeding the native Turn-tail summary. */
+export declare const novelMutationDefinition: ConversationNodeDefinition<MutationState>;
+type TurnSummaryProps = PropsRuntime<'conversation.chat.turnTail'> & PropsLocale<'studio-panel'> & Pick<StudioApiInjected, 'postStudioApi'> & {
+    matched: NovelMutationSummary;
+};
+export declare function TurnMutationSummaryView({ matched, openFile, postStudioApi, t }: TurnSummaryProps): import("react").JSX.Element;
+export {};

package/packages/studio-panel/lib/types/client/VditorBody.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Vditor live (IR) body editor. The engine is vendored with this plugin and
+ * served by the dsh host at a same-origin route; Studio remains a headless
+ * domain backend and never supplies browser assets.
+ *
+ * Mirrors Studio's options: mode 'ir', lang zh_CN, cache off, dark theme
+ * mapped from the dsh shell's `body[data-ds-dark-theme]` (ui-theme's
+ * boot-theme contract) — classic when light, dark when dark, with a
+ * MutationObserver following live theme switches. Toolbar is Studio's
+ * compact subset plus headings/code/table (card-body scope).
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ManuscriptSelection } from './manuscript-selection.ts';
+import type { ManuscriptAnnotation } from './manuscript-annotations.ts';
+/** The slice of the bundled Vditor API this editor uses. */
+interface VditorInstance {
+    getValue: () => string;
+    getSelection?: () => string;
+    insertValue?: (value: string, render?: boolean) => void;
+    setTheme: (theme: string, contentTheme?: string, codeTheme?: string, contentThemePath?: string) => void;
+    destroy: () => void;
+}
+type VditorCtor = new (host: HTMLElement, options: Record<string, unknown>) => VditorInstance;
+type TFunc = PropsLocale<'studio-panel'>['t'];
+/**
+ * Attach Vditor's packaged CSS and resolve the constructor bundled into this
+ * plugin. Auxiliary language/theme assets continue to use the same-origin
+ * vendor route.
+ */
+export declare function loadVditor(): Promise<VditorCtor>;
+export type ManuscriptEditorApi = {
+    insertAtCaret: (markdown: string) => void;
+    revealQuote: (quote: string, start: number) => boolean;
+};
+interface VditorBodyProps {
+    /** Initial markdown (the editor is the source of truth afterwards). */
+    initial: string;
+    onChange: (value: string) => void;
+    onSelectionChange?: (selection: ManuscriptSelection | null) => void;
+    onReady?: () => void;
+    onFailed: () => void;
+    disabled: boolean;
+    /** The consumer can synchronously retain callbacks delivered during cleanup. */
+    flushOnLeave?: boolean;
+    annotations?: readonly ManuscriptAnnotation[];
+    onInsertMarker?: () => void;
+    onEditorApi?: (api: ManuscriptEditorApi | null) => void;
+}
+/** One Vditor IR instance bound to the shell theme; destroyed on unmount. */
+export declare function VditorBody({ initial, onChange, onSelectionChange, onReady, onFailed, disabled, flushOnLeave, annotations, onInsertMarker, onEditorApi, }: VditorBodyProps): import("react").JSX.Element;
+/** Loading line shown while the Vditor script is in flight. */
+export declare function VditorLoading({ t }: {
+    t: TFunc;
+}): import("react").JSX.Element;
+export {};

package/packages/studio-panel/lib/types/client/WorkbenchStore.d.ts

@@ -0,0 +1,121 @@
+export type ConnectionState = 'connecting' | 'online' | 'offline';
+export type EditorStatus = 'idle' | 'loading' | 'saved' | 'dirty' | 'saving' | 'conflict' | 'offline';
+export type ResourceKey = 'workspace' | 'manuscript' | 'outline' | 'assets' | 'tasks' | 'benchmark' | 'models' | 'dag' | 'graph' | 'research' | 'revisions';
+/**
+ * The panel's Workspace identity (docs/WORKSPACE_CONTEXT_CONTRACT.md §9):
+ * `root` is the dsh Workspace's canonical absolute path — the only identity
+ * that matters for invalidate filtering; `workspaceId` is the UI/wire
+ * reference carried on every proxied request.
+ */
+export interface WorkbenchContext {
+    workspaceId: string;
+    root: string;
+    sessionId?: string | undefined;
+}
+export interface ReviewSummary {
+    score: number | null;
+    passed: boolean | null;
+    issues: number;
+    issueDetails: readonly unknown[];
+    stale: boolean;
+    reviewedAt: string;
+    sourceRevision: string;
+    currentSourceRevision: string;
+}
+export interface ChapterSummary {
+    id: string;
+    /** Stable server identity when supplied. An empty value means path is the only available identity. */
+    documentId: string;
+    /** Stable position in canonical reading order. Repeated documents receive distinct occurrences. */
+    occurrenceId: string;
+    volumeId: string;
+    status: string;
+    path: string;
+    title: string;
+    subtitle: string;
+    revision: string;
+    readingIndex: number | null;
+    writingUnits: number | null;
+    updatedAt: string;
+    review: ReviewSummary;
+}
+export interface WritingProgress {
+    bookUnits: number;
+    bookTarget: number;
+    chapterTarget: number;
+}
+export interface WorkbenchSnapshot {
+    connection: ConnectionState;
+    /** Bound Workspace context; null = no Workspace bound, panel issues no proxied requests. */
+    context: WorkbenchContext | null;
+    /** Local generation counter, bumped on every context switch. */
+    contextEpoch: number;
+    /** Contract error code blocking this context (e.g. WORKSPACE_NOT_INITIALIZED), null when healthy. */
+    workspaceError: string | null;
+    projectTitle: string;
+    currentChapterId: string;
+    activeChapterPath: string;
+    chapters: readonly ChapterSummary[];
+    writingProgress: WritingProgress;
+    workspace: unknown;
+    tasks: unknown;
+    activeTasks: number;
+    editorStatus: EditorStatus;
+    editorMessage: string;
+    epochs: Readonly<Record<ResourceKey, number>>;
+    lastUpdatedAt: number;
+}
+type Listener = () => void;
+declare class NovelWorkbenchStore {
+    private snapshot;
+    private readonly listeners;
+    private pollTimer;
+    private eventSource;
+    private refreshPromise;
+    private refreshController;
+    private taskSignature;
+    /** Raw tasks payload of the last committed refresh (terminal-diff baseline). */
+    private tasksPayload;
+    private revision;
+    private revisionInitialized;
+    /** Last seen upstream context_epoch (background-transition hint channel). */
+    private contextEpoch;
+    private contextEpochInitialized;
+    private pollTicks;
+    /** Context generation: every setContext bump invalidates in-flight work. */
+    private generation;
+    readonly subscribe: (listener: Listener) => (() => void);
+    readonly getSnapshot: () => WorkbenchSnapshot;
+    /**
+     * The context barrier (contract §9). A changed context: bumps the
+     * generation (late responses from the old generation are dropped on
+     * commit), resets every per-context slice back to INITIAL, aborts the
+     * in-flight refresh, closes the old SSE stream and poll timer, zeroes the
+     * revision/task baselines, rebinds the API layer's context headers, then
+     * reconnects and refreshes under the new Workspace. An identical context
+     * is a no-op; null stops everything and clears the panel.
+     */
+    setContext(next: WorkbenchContext | null): void;
+    setActiveChapter(path: string): void;
+    setEditorStatus(status: EditorStatus, message?: string): void;
+    invalidate(resource: ResourceKey): void;
+    refresh(): Promise<void>;
+    /**
+     * Two-layer sync. Layer one is the always-on 5s invalidation poll: it is
+     * the only channel that observes background task transitions, because the
+     * bridge merges the upstream context_epoch into invalidation.json and task
+     * transitions bump it without any bridge-local write. Layer two is SSE,
+     * the instant channel for proxied writes and agent mutations; its state
+     * never gates the poll loop.
+     */
+    private start;
+    private startPolling;
+    private consumeMutation;
+    private stop;
+    private pollInvalidation;
+    private refreshNow;
+    private patch;
+}
+export declare const workbenchStore: NovelWorkbenchStore;
+export declare function useWorkbench(): WorkbenchSnapshot;
+export {};

package/packages/studio-panel/lib/types/client/api.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Same-origin read path to the local OpenWrite Studio API through the host
+ * half's proxy route (registered by @dsh-novel/openwrite-bridge, see
+ * packages/openwrite-bridge domain.ts). Studio itself sends no CORS headers,
+ * so the browser can only reach it via this proxy.
+ *
+ * Workspace context (docs/WORKSPACE_CONTEXT_CONTRACT.md §2.2): the browser
+ * only ever sends the dsh workspace id (plus an optional session id for
+ * audit) — never a path. Every proxied request carries the context headers;
+ * with no context bound the panel must not issue proxied requests at all, so
+ * all three request helpers fail closed with WORKSPACE_CONTEXT_MISSING.
+ */
+/** Host-half proxy prefix (kept in sync with openwrite-bridge domain.ts). */
+export declare const API_PROXY_BASE = "/studio-panel/api";
+/** Browser-side Workspace identity stamped onto every proxied request. */
+export interface StudioContext {
+    workspaceId: string;
+    sessionId?: string | undefined;
+}
+/**
+ * Bind (or clear, with null) the Workspace context for all proxied requests.
+ * Owned by the WorkbenchStore context barrier — components never call this
+ * directly; they go through `workbenchStore.setContext`.
+ */
+export declare function setStudioContext(next: StudioContext | null): void;
+/** The currently bound Workspace context, or null when unbound. */
+export declare function getStudioContext(): StudioContext | null;
+/**
+ * Context headers for the contract's browser wire format. Throws a
+ * StudioApiError (code WORKSPACE_CONTEXT_MISSING) when no context is bound —
+ * fail closed, never fall back to a context-less request.
+ */
+export declare function studioContextHeaders(): Record<string, string>;
+/**
+ * Injected share of the data views (大纲 / 资产): JSON fetches against the
+ * Studio API. `postStudioApi` only reaches the host proxy's write allowlist
+ * (asset domain; see openwrite-bridge domain.ts WRITABLE_PATHS).
+ */
+export interface StudioApiInjected {
+    fetchStudioApi: (path: string) => Promise<unknown>;
+    postStudioApi: (path: string, body: unknown) => Promise<unknown>;
+    putStudioApi: (path: string, body: unknown, context?: StudioContext) => Promise<unknown>;
+}
+/** A Studio API failure that keeps the HTTP status (409 = optimistic-lock conflict) and contract error code. */
+export declare class StudioApiError extends Error {
+    readonly status: number;
+    readonly code: string | undefined;
+    readonly details: Readonly<Record<string, unknown>>;
+    constructor(message: string, status: number, code?: string, details?: Record<string, unknown>);
+}
+/**
+ * GET one Studio API path through the proxy and parse the JSON body. Throws
+ * a StudioApiError carrying the upstream status and message on any non-2xx
+ * answer (including the proxy's own 502 when Studio is down).
+ * @param path - Studio API path beginning with `/`, query string allowed
+ *   (e.g. `/assets?kind=character`).
+ * @param signal - optional caller abort (context switches cancel in-flight reads).
+ * @returns the parsed JSON payload.
+ */
+export declare function fetchStudioApi(path: string, signal?: AbortSignal): Promise<unknown>;
+/**
+ * POST a JSON body to one allowlisted Studio API path through the proxy and
+ * parse the JSON response. Throws StudioApiError with the upstream status and
+ * message on any non-2xx answer (409 = revision conflict, surfaced by the
+ * asset editor as "reload and retry").
+ * @param path - allowlisted Studio API path (e.g. `/assets/update`).
+ * @param body - JSON-serializable request body, forwarded verbatim.
+ * @returns the parsed JSON payload.
+ */
+export declare function postStudioApi(path: string, body: unknown): Promise<unknown>;
+/** PUT a JSON body to one allowlisted Studio API path. */
+export declare function putStudioApi(path: string, body: unknown, context?: StudioContext): Promise<unknown>;

package/packages/studio-panel/lib/types/client/asset-drafts.d.ts

@@ -0,0 +1,20 @@
+import type { AssetEditorDraft, AssetEditorSource } from './AssetEditor.tsx';
+export interface AssetDraftContext {
+    workspaceId: string;
+    root: string;
+}
+export interface AssetDraftIdentity extends AssetDraftContext {
+    kind: string;
+    id: string;
+}
+export interface AssetDraftRecord extends AssetDraftIdentity {
+    baseRevision: string;
+    source: AssetEditorSource;
+    draft: AssetEditorDraft;
+}
+export declare function readAssetDraft(identity: AssetDraftIdentity): AssetDraftRecord | null;
+export declare function latestAssetDraft(context: AssetDraftContext): AssetDraftRecord | null;
+export declare function writeAssetDraft(record: AssetDraftRecord): boolean;
+export declare function removeAssetDraft(identity: AssetDraftIdentity): void;
+/** A slow save from an unmounted editor must not erase a newer local draft. */
+export declare function removeAssetDraftIfUnchanged(identity: AssetDraftIdentity, saved: AssetEditorDraft): void;

package/packages/studio-panel/lib/types/client/benchmark-options.d.ts

@@ -0,0 +1,43 @@
+export type BenchmarkTaskType = 'chapter' | 'outline';
+export type BenchmarkExecutionMode = 'framework' | 'creative';
+export interface BenchmarkPipeline {
+    id: string;
+    executionMode: string;
+    nodes: {
+        id: string;
+        label: string;
+        dependsOn: string[];
+    }[];
+    reviewDomains: {
+        id: string;
+        label: string;
+    }[];
+}
+export interface BenchmarkOptions {
+    chapters: {
+        id: string;
+        title: string;
+        status: string;
+        hasManuscript: boolean;
+        available: boolean;
+        reason: string;
+    }[];
+    nextChapterId: string;
+    defaultOutlineStart: number;
+    outlineStartMin: number;
+    outlineStartMax: number;
+    outlineCountMax: number;
+    tasks: {
+        taskType: BenchmarkTaskType;
+        executionModes: string[];
+        pipelines: BenchmarkPipeline[];
+        readiness: {
+            ok: boolean;
+            code: string;
+            message: string;
+        };
+    }[];
+}
+export declare function parseBenchmarkPipeline(value: unknown): BenchmarkPipeline | null;
+export declare function parseBenchmarkOptions(value: unknown): BenchmarkOptions;
+export declare function positiveInteger(value: string): number | null;

package/packages/studio-panel/lib/types/client/draft-store.d.ts

@@ -0,0 +1,26 @@
+/** IndexedDB-backed recovery drafts for manuscript documents. */
+export declare const MANUSCRIPT_DRAFT_FORMAT_VERSION: 1;
+export interface ManuscriptDraftIdentity {
+    workspaceId: string;
+    novelId: string;
+    path: string;
+}
+export interface ManuscriptDraftRecord extends ManuscriptDraftIdentity {
+    key: string;
+    formatVersion: typeof MANUSCRIPT_DRAFT_FORMAT_VERSION;
+    baseRevision: string;
+    content: string;
+    updatedAt: number;
+}
+export interface ManuscriptDraftStore {
+    load: (identity: ManuscriptDraftIdentity) => Promise<ManuscriptDraftRecord | null>;
+    save: (record: ManuscriptDraftRecord) => Promise<void>;
+    remove: (identity: ManuscriptDraftIdentity) => Promise<void>;
+    removeIfContent: (identity: ManuscriptDraftIdentity, content: string) => Promise<boolean>;
+}
+export declare class ManuscriptDraftStorageError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare function manuscriptDraftKey(identity: ManuscriptDraftIdentity): string;
+export declare function manuscriptNovelId(workspacePayload: unknown, path: string): string;
+export declare const manuscriptDraftStore: ManuscriptDraftStore;