@dsh-workbench/module-tools 1.1.12 → 1.1.14-beta.0

package/template-diy/src/components/OverviewCard.tsx.tpl

@@ -1,83 +1,74 @@
-import { createElement as h } from 'react';
+import { createElement as h, useState } from 'react';
 import { kit } from '@dsh-workbench/core/client';
-import { LIST_LIMIT, formatBytes, overviewStateOf, type OverviewReady, type OverviewState } from '../model/overview';
+import { overviewStateOf, type OverviewReady } from '../model/overview';
+import { RUN_RESOURCE, type SampleRun } from '../model/flow';
+import { NOTE_RESOURCE, NOTES_ROUTE, type Note } from '../model/notes';
+import { LIMIT_DEFAULT, PREFS_RESOURCE, PREFS_ROUTE, type Prefs } from '../model/prefs';
+import { NotesSection } from './NotesSection';
+import { OverviewBody } from './OverviewBody';
+import { PrefsSection } from './PrefsSection';
+import { RunSection } from './RunSection';
 import styles from './OverviewCard.module.css';
 
 const UNIT_ID = '__UNIT__';
 const OVERVIEW_ROUTE = `${UNIT_ID}/overview`;
 
-const { Card, CenteredState, EmptyState, IconPanelScreen, Row, Rows, StateBlock } = kit.components;
-const { useApiResource } = kit.hooks;
+const { Card } = kit.components;
+const { useApiResource, useHostWrite, useLongTask } = kit.hooks;
 
-type Rendered = ReturnType<typeof h>;
-type Translate = (key: string, params?: Record<string, unknown>) => string;
+interface NotesPayload {
+  readonly ok: boolean;
+  readonly notes?: readonly Note[];
+}
+
+interface PrefsPayload {
+  readonly ok: boolean;
+  readonly prefs?: Prefs;
+}
 
 export interface OverviewCardProps {
   readonly path: string;
   readonly refreshToken: number;
   readonly onRefresh: () => void;
-  readonly t: Translate;
+  readonly t: (key: string) => string;
 }
 
-function bodyOf(state: OverviewState, t: Translate): Rendered {
-  if (state.kind === 'idle') {
-    return h(CenteredState, { icon: null, title: t(`${UNIT_ID}.needProject`), compact: true });
-  }
-  if (state.kind === 'loading') {
-    return h(CenteredState, {
-      icon: null,
-      title: t(`${UNIT_ID}.loading`),
-      hint: t(`${UNIT_ID}.loadingHint`),
-      compact: true,
-    });
-  }
-  if (state.kind === 'error') {
-    return h(CenteredState, {
-      icon: null,
-      title: t(`${UNIT_ID}.errorTitle`),
-      detail: state.detail,
-      hint: t(`${UNIT_ID}.errorHint`),
-      compact: true,
-    });
-  }
-  if (state.kind === 'empty') {
-    return h(EmptyState, { text: t(`${UNIT_ID}.empty`), icon: h(IconPanelScreen, { size: 20 }), compact: true });
-  }
-  const payload = state.payload;
-  return h(
-    StateBlock,
-    {
-      title: payload.path,
-      hint:
-        `${String(payload.files)}${t(`${UNIT_ID}.fileUnit`)} · ` +
-        `${String(payload.dirs)}${t(`${UNIT_ID}.dirUnit`)} · ${formatBytes(payload.bytes)}`,
-      resolving: t(`${UNIT_ID}.largest`),
-    },
-    h(
-      'div',
-      { className: styles.largest },
-      h(
-        Rows,
-        null,
-        ...payload.largest.map((file) =>
-          h(Row, {
-            key: file.name,
-            label: file.name,
-            value: `${formatBytes(file.bytes)} · ${file.mtime}`,
-          }),
-        ),
-      ),
-    ),
-  );
-}
+export function OverviewCard(props: OverviewCardProps): ReturnType<typeof h> {
+  const [draft, setDraft] = useState('');
+  const [notesToken, setNotesToken] = useState(0);
+  const [prefsToken, setPrefsToken] = useState(0);
+  const path = props.path === '' ? undefined : props.path;
+
+  const prefsResource = useApiResource<PrefsPayload>(PREFS_ROUTE, { path }, prefsToken, {
+    enabled: props.path !== '',
+  });
+  const limit = prefsResource.value?.prefs?.limit ?? LIMIT_DEFAULT;
+  const resource = useApiResource<OverviewReady>(OVERVIEW_ROUTE, { path, limit }, props.refreshToken, {
+    enabled: props.path !== '',
+  });
+  const notesResource = useApiResource<NotesPayload>(NOTES_ROUTE, { path }, notesToken, {
+    enabled: props.path !== '',
+  });
+  const feed = useLongTask<SampleRun>({
+    unit: UNIT_ID,
+    workspace: props.path === '' ? null : props.path,
+  });
+  const flowWrite = useHostWrite<{ runId: string }>({
+    channel: 'actions',
+    resource: RUN_RESOURCE,
+    networkText: props.t(`${UNIT_ID}.network`),
+  });
+  const noteWrite = useHostWrite<{ notes?: readonly Note[] }>({
+    channel: 'actions',
+    resource: NOTE_RESOURCE,
+    networkText: props.t(`${UNIT_ID}.network`),
+  });
+  const prefsWrite = useHostWrite<Prefs>({
+    channel: 'prefs',
+    resource: PREFS_RESOURCE,
+    networkText: props.t(`${UNIT_ID}.network`),
+  });
 
-export function OverviewCard(props: OverviewCardProps): Rendered {
-  const resource = useApiResource<OverviewReady>(
-    OVERVIEW_ROUTE,
-    { path: props.path === '' ? undefined : props.path, limit: LIST_LIMIT },
-    props.refreshToken,
-    { enabled: props.path !== '' },
-  );
   const state = overviewStateOf({ phase: resource.phase, value: resource.value, error: resource.error });
   return h(
     Card,
@@ -85,8 +76,58 @@ export function OverviewCard(props: OverviewCardProps): Rendered {
       t: props.t,
       title: props.t(`${UNIT_ID}.cardTitle`),
       refreshing: resource.phase === 'loading',
-      onRefresh: props.onRefresh,
+      onRefresh: () => {
+        props.onRefresh();
+        feed.refresh();
+        setNotesToken((token) => token + 1);
+        setPrefsToken((token) => token + 1);
+      },
     },
-    bodyOf(state, props.t),
+    h(OverviewBody, { state, t: props.t }),
+    h(RunSection, {
+      path: props.path,
+      className: styles.block,
+      t: props.t,
+      feed,
+      write: flowWrite,
+      failed: flowWrite.failed,
+    }),
+    h(NotesSection, {
+      path: props.path,
+      className: styles.block,
+      lineClassName: styles.line,
+      t: props.t,
+      notes: notesResource.value?.notes ?? [],
+      draft,
+      onDraft: setDraft,
+      write: {
+        busy: noteWrite.busy,
+        failed: noteWrite.failed,
+        send: async (text: string) => {
+          const outcome = await noteWrite.send({ path: props.path, text });
+          if (outcome.ok) {
+            setDraft('');
+            setNotesToken((token) => token + 1);
+            props.onRefresh();
+          }
+          return outcome;
+        },
+      },
+    }),
+    h(PrefsSection, {
+      path: props.path,
+      t: props.t,
+      limit,
+      busy: prefsWrite.busy,
+      failed: prefsWrite.failed,
+      onChange: (next: number) => {
+        void prefsWrite.send({ workspace: props.path, limit: next }).then((outcome) => {
+          if (outcome.ok) {
+            setPrefsToken((token) => token + 1);
+            props.onRefresh();
+          }
+        });
+      },
+    }),
   );
 }

package/template-diy/src/components/PrefsSection.tsx.tpl

@@ -0,0 +1,36 @@
+import { createElement as h } from 'react';
+import { kit } from '@dsh-workbench/core/client';
+import { LIMIT_CHOICES } from '../model/prefs';
+
+const { Field, Note, SelectField } = kit.components;
+const UNIT_ID = '__UNIT__';
+
+export interface PrefsSectionProps {
+  readonly path: string;
+  readonly t: (key: string) => string;
+  readonly limit: number;
+  readonly busy: boolean;
+  readonly failed: string | null;
+  readonly onChange: (limit: number) => void;
+}
+
+export function PrefsSection({ path, t, limit, busy, failed, onChange }: PrefsSectionProps): ReturnType<typeof h> {
+  const known = LIMIT_CHOICES.includes(limit as (typeof LIMIT_CHOICES)[number]);
+  const choices = known ? [...LIMIT_CHOICES] : [...LIMIT_CHOICES, limit].sort((a, b) => a - b);
+  return h(
+    Field,
+    { label: t(`${UNIT_ID}.prefsLabel`), hint: t(`${UNIT_ID}.prefsHint`) },
+    failed === null ? null : h(Note, null, failed),
+    h(SelectField, {
+      value: String(limit),
+      disabled: path === '' || busy,
+      options: choices.map((choice) => ({
+        value: String(choice),
+        label: `${String(choice)}${t(`${UNIT_ID}.prefsUnit`)}`,
+      })),
+      onChange: (value: string) => {
+        onChange(Number(value));
+      },
+    }),
+  );
+}

package/template-diy/src/components/RunSection.tsx.tpl

@@ -0,0 +1,69 @@
+import { createElement as h } from 'react';
+import { Button } from '@deepseek-ai/dsh-client-ui-primitives';
+import { kit } from '@dsh-workbench/core/client';
+import { headlineOf, runIsLive, type SampleRun } from '../model/flow';
+
+const { LongTaskRow, Note } = kit.components;
+const UNIT_ID = '__UNIT__';
+
+export interface RunSectionProps {
+  readonly path: string;
+  readonly className: string;
+  readonly t: (key: string) => string;
+  readonly feed: {
+    readonly runs: readonly SampleRun[];
+    stop(id: string): Promise<unknown>;
+    readonly stopping: string | null;
+    readonly stopFailed: string | null;
+    refresh(): void;
+  };
+  readonly write: { readonly busy: boolean; send(body: Record<string, unknown>): Promise<{ readonly ok: boolean }> };
+  readonly failed: string | null;
+}
+
+export function RunSection({ path, className, t, feed, write, failed }: RunSectionProps): ReturnType<typeof h> {
+  const run = feed.runs[0];
+  const live = run !== undefined && runIsLive(run);
+  const stop =
+    run === undefined || !live
+      ? undefined
+      : {
+          onStop: () => {
+            void feed.stop(run.id);
+          },
+          label: t(`${UNIT_ID}.stopLabel`),
+          askLabel: t(`${UNIT_ID}.stopAsk`),
+          busy: feed.stopping === run.id,
+          failed: feed.stopFailed,
+        };
+  return h(
+    'div',
+    { className },
+    h(
+      Button,
+      {
+        variant: 'ghost',
+        size: 'sm',
+        disabled: path === '' || write.busy,
+        onClick: () => {
+          void write.send({ path }).then((outcome) => {
+            if (outcome.ok) feed.refresh();
+          });
+        },
+      },
+      t(`${UNIT_ID}.runSample`),
+    ),
+    failed === null ? null : h(Note, null, failed),
+    run === undefined
+      ? h(Note, null, t(`${UNIT_ID}.runHint`))
+      : h(LongTaskRow, {
+          status: run.status,
+          headline: headlineOf(run),
+          problem: run.status === 'failed' ? run.why : undefined,
+          steps: run.steps,
+          raw: run.why,
+          stepsTitle: t(`${UNIT_ID}.stepsTitle`),
+          stop,
+        }),
+  );
+}

package/template-diy/src/components/{OverviewCard.test.ts.tpl → __tests__/OverviewCard.test.ts.tpl}

@@ -7,8 +7,20 @@ const shell = vi.hoisted(() => ({
     readonly error?: { readonly code: string; readonly message: string };
   },
   readEnabled: undefined as boolean | undefined,
+  writeFailed: null as string | null,
 }));
 
+vi.mock('react', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('react')>();
+  return {
+    ...actual,
+    useState: (initial: unknown) => [
+      typeof initial === 'function' ? (initial as () => unknown)() : initial,
+      () => {},
+    ],
+  };
+});
+
 vi.mock('@dsh-workbench/core/client', () => ({
   kit: {
     hooks: {
@@ -16,20 +28,44 @@ vi.mock('@dsh-workbench/core/client', () => ({
         shell.readEnabled = options?.enabled;
         return shell.resource;
       },
+      useHostWrite: () => ({
+        busy: false,
+        failed: shell.writeFailed,
+        detail: null,
+        send: async () => ({ ok: true, value: {} }),
+        fail: () => {},
+        clear: () => {},
+      }),
+      useLongTask: () => ({
+        runs: [],
+        stop: async () => ({ ok: true }),
+        stopping: null,
+        stopFailed: null,
+        refresh: () => {},
+      }),
     },
     components: {
       Card: () => null,
       CenteredState: () => null,
       EmptyState: () => null,
+      Field: () => null,
       StateBlock: () => null,
       IconPanelScreen: () => null,
       Rows: () => null,
       Row: () => null,
+      LongTaskRow: () => null,
+      Note: () => null,
+      SelectField: () => null,
+      TextField: () => null,
     },
   },
 }));
 
-import { OverviewCard } from './OverviewCard';
+vi.mock('@deepseek-ai/dsh-client-ui-primitives', () => ({
+  Button: () => null,
+}));
+
+import { OverviewCard } from '../OverviewCard';
 
 function textOf(value: unknown, out: string[] = []): string[] {
   if (typeof value === 'string') {
@@ -47,6 +83,10 @@ function textOf(value: unknown, out: string[] = []): string[] {
   }
   if (typeof value === 'object') {
     const record = value as Record<string, unknown>;
+    if (typeof record['type'] === 'function' && record['props'] !== undefined) {
+      const rendered = (record['type'] as (props: unknown) => unknown)(record['props']);
+      if (rendered !== null && rendered !== undefined) return textOf(rendered, out);
+    }
     const source = 'type' in record && 'props' in record ? (record.props as Record<string, unknown>) : record;
     for (const one of Object.values(source)) {
       if (typeof one !== 'function') textOf(one, out);
@@ -115,4 +155,14 @@ describe('OverviewCard：待机 / 加载 / 就绪 / 就绪但空 / 出错', () =
     expect(text).toContain('/real/workbench');
     expect(text).not.toContain('__UNIT__.loading');
   });
+
+  it('写失败留在卡上（不静默）', () => {
+    shell.resource = {
+      phase: 'ready',
+      value: { ok: true, path: '/real/workbench', files: 1, dirs: 0, bytes: 10, largest: [] },
+    };
+    shell.writeFailed = '网络不通，没发出去';
+    expect(textOf(OverviewCard(cardProps)).join(' ')).toContain('网络不通，没发出去');
+    shell.writeFailed = null;
+  });
 });

package/template-diy/src/declared-tools.ts.tpl

@@ -0,0 +1,6 @@
+export const DECLARED_TOOLS = {
+  run: { name: '__UNIT___run', writes: false },
+  addNote: { name: '__UNIT___add_note', writes: true },
+} as const;
+
+export type DeclaredToolKey = keyof typeof DECLARED_TOOLS;

package/template-diy/src/host/notes.ts.tpl

@@ -0,0 +1,92 @@
+import { randomUUID } from 'node:crypto';
+import type { DshToolDefinition, UnitMountDeps } from '@dsh-workbench/core/contract';
+import { TEXT_OUTPUT, recordOf, sessionWorkspace, textOf } from '@dsh-workbench/shared/host';
+import { DECLARED_TOOLS } from '../declared-tools';
+import {
+  NOTE_FILE,
+  UNIT_ID,
+  addNoteOf,
+  noteIdOf,
+  noteProblemOf,
+  notesOf,
+  type Note,
+} from '../model/notes';
+
+export interface NotesResult {
+  readonly ok: boolean;
+  readonly notes?: readonly Note[];
+  readonly note?: Note;
+  readonly code?: string;
+  readonly message?: string;
+  readonly text?: string;
+}
+
+export interface Notes {
+  list(workspace: string): Note[];
+  add(workspace: string, rawText: unknown): NotesResult;
+  readonly tool: DshToolDefinition;
+  handle(payload: unknown): unknown;
+}
+
+export function createNotes(deps: UnitMountDeps): Notes {
+  const storeAt = (workspace: string) => deps.store.for(UNIT_ID, workspace);
+
+  const list = (workspace: string): Note[] => notesOf(storeAt(workspace).read(NOTE_FILE));
+
+  const add = (workspace: string, rawText: unknown): NotesResult => {
+    const problem = noteProblemOf(rawText);
+    if (problem !== undefined) return { ok: false, code: 'note-invalid', message: problem };
+    const at = new Date().toISOString();
+    const existing = list(workspace);
+    const { note, notes } = addNoteOf(
+      existing,
+      String(rawText),
+      at,
+      noteIdOf(at, randomUUID().slice(0, 8)),
+    );
+    storeAt(workspace).write(NOTE_FILE, notes);
+    return { ok: true, note, notes };
+  };
+
+  const tool: DshToolDefinition = {
+    name: DECLARED_TOOLS.addNote.name,
+    description: '往当前工作区的模块笔记里加一条（最多 20 条，只写本模块自己的文件夹，不动平台）。',
+    parameters: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: '要记的一句话（200 字以内）。' },
+      },
+      required: ['text'],
+      additionalProperties: false,
+    },
+    output: TEXT_OUTPUT,
+    async execute(raw, exec) {
+      const workspace = sessionWorkspace(exec);
+      if (workspace === null || workspace === '') {
+        return { ok: false, text: '这个会话没有工作区：先打开一个项目再记。' };
+      }
+      const result = add(workspace, recordOf(raw)['text']);
+      return result.ok
+        ? { ok: true, text: `记下了：${result.note?.text ?? ''}` }
+        : { ok: false, text: result.message ?? '没记上' };
+    },
+  };
+
+  return {
+    list,
+    add,
+    tool,
+    handle(payload: unknown): unknown {
+      const body = recordOf(payload);
+      const workspace = textOf(body['path']);
+      if (workspace === '') {
+        return { ok: false, error: { code: 'no-workspace', message: '先打开一个项目再记' } };
+      }
+      const result = add(workspace, body['text']);
+      if (!result.ok) {
+        return { ok: false, error: { code: result.code ?? 'note-invalid', message: result.message ?? '没记上' } };
+      }
+      return { ok: true, notes: result.notes, text: `记下了：${result.note?.text ?? ''}` };
+    },
+  };
+}

package/template-diy/src/host/overview.ts.tpl

@@ -0,0 +1,57 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import type { OverviewFile, OverviewPayload } from '../model/overview';
+import { LIMIT_DEFAULT, LIMIT_MAX } from '../model/prefs';
+
+export const DEFAULT_LIMIT = LIMIT_DEFAULT;
+export const MAX_LIMIT = LIMIT_MAX;
+
+export function readOverview(path: string, limit: number): OverviewPayload {
+  const entries = readdirSync(path, { withFileTypes: true });
+  const files: OverviewFile[] = [];
+  let dirs = 0;
+  let bytes = 0;
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      dirs += 1;
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const info = statSync(join(path, entry.name));
+    bytes += info.size;
+    files.push({ name: entry.name, bytes: info.size, mtime: new Date(info.mtimeMs).toISOString() });
+  }
+  files.sort((a, b) => b.bytes - a.bytes || a.name.localeCompare(b.name));
+  return { path, files: files.length, dirs, bytes, largest: files.slice(0, limit) };
+}
+
+function searchParam(search: URLSearchParams, name: string): string | undefined {
+  const raw = search.get(name);
+  return raw === null || raw === '' ? undefined : raw;
+}
+
+function limitOf(search: URLSearchParams): number {
+  const raw = searchParam(search, 'limit');
+  if (raw === undefined) return DEFAULT_LIMIT;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return DEFAULT_LIMIT;
+  return Math.min(MAX_LIMIT, Math.max(1, Math.trunc(parsed)));
+}
+
+export function overviewAnswer(search: URLSearchParams): unknown {
+  const target = searchParam(search, 'path');
+  if (target === undefined) {
+    return { ok: false, error: { code: 'no-path', message: '没告诉我要看哪个目录' } };
+  }
+  try {
+    return { ok: true, ...readOverview(target, limitOf(search)) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: {
+        code: 'overview-unreadable',
+        message: error instanceof Error ? error.message : String(error),
+      },
+    };
+  }
+}