rpr-cli 0.1.26__tar.gz → 0.1.27__tar.gz

{rpr_cli-0.1.26 → rpr_cli-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpr-cli
-Version: 0.1.26
+Version: 0.1.27
 Summary: RPR CLI -- React Python Rust monorepo scaffolding orchestrator
 License-Expression: MIT
 License-File: LICENSE

rpr_cli-0.1.27/src/rpr/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.27"

{rpr_cli-0.1.26 → rpr_cli-0.1.27}/src/rpr/checks/instructions.py

@@ -82,6 +82,7 @@ def check_instructions(
         ("fetch_service", "has_ui"),
         ("sticky_navigation", "has_ui"),
         ("virtual_list", "has_ui"),
+        ("chat", "has_ui"),
     ]
 
     for tid, prereq in template_ids:

{rpr_cli-0.1.26 → rpr_cli-0.1.27}/src/rpr/commands/add.py

@@ -62,6 +62,13 @@ def template(
             "--include-tests", help="Include unit-test companions when available."
         ),
     ] = False,
+    install: Annotated[
+        bool | None,
+        typer.Option(
+            "--install/--no-install",
+            help="Install npm dependencies after writing files (default depends on template).",
+        ),
+    ] = None,
     output_dir: Annotated[
         str | None,
         typer.Option(
@@ -115,24 +122,43 @@ def template(
         )
         raise typer.Exit(1)
 
-    selected_files = list(entry.files)
-    if include_tests:
-        selected_files.extend(entry.test_files)
-        selected_files.extend(entry.config_files)
-
-    rendered_files = []
-    for template_file in selected_files:
-        source_file = source_dir / template_file.source_subdir / template_file.source_filename
-        code = _render_template_file(source_file, template_file, variables)
-        target_path = _resolve_target_path(ctx, template_file, variables, output_dir)
-        rendered_files.append((template_file, target_path, code))
+    ordered_entries: list[tuple[TemplateEntry, bool]] = []
+    for required_id in entry.requires:
+        required_entry = TEMPLATES.get(required_id)
+        if required_entry is not None:
+            ordered_entries.append((required_entry, True))
+    ordered_entries.append((entry, False))
+
+    seen_targets: set[Path] = set()
+    rendered_files: list[tuple[TemplateFile, Path, str, bool]] = []
+    for current_entry, reuse_mode in ordered_entries:
+        files_for_entry = list(current_entry.files)
+        if include_tests:
+            files_for_entry.extend(current_entry.test_files)
+            files_for_entry.extend(current_entry.config_files)
+        for template_file in files_for_entry:
+            target_path = _resolve_target_path(
+                ctx, template_file, variables, output_dir
+            )
+            if target_path in seen_targets:
+                continue
+            seen_targets.add(target_path)
+            source_file = (
+                source_dir / template_file.source_subdir / template_file.source_filename
+            )
+            code = _render_template_file(source_file, template_file, variables)
+            rendered_files.append((template_file, target_path, code, reuse_mode))
 
     skipped_config_paths: list[Path] = []
+    reused_paths: list[Path] = []
     writable_files = []
-    for template_file, target_path, code in rendered_files:
+    for template_file, target_path, code, reuse_mode in rendered_files:
         if dry_run or not target_path.exists() or force:
             writable_files.append((template_file, target_path, code))
             continue
+        if reuse_mode:
+            reused_paths.append(target_path)
+            continue
         if template_file.role == "config":
             console.print(
                 f"[bold yellow]Warning:[/] Config already exists, leaving it unchanged: {target_path}"
@@ -150,11 +176,24 @@ def template(
     for _, target_path, code in writable_files:
         ctx.write_file(target_path, code)
 
+    _update_root_index(
+        ctx,
+        [target_path for _, target_path, _ in writable_files],
+        variables,
+        output_dir,
+    )
+
     _print_include_test_notes(entry, include_tests, skipped_config_paths)
 
+    _maybe_install_dependencies(ctx, ordered_entries, include_tests, install)
+
     console.print("\n[bold green]Done![/] Template files written:")
     for _, target_path, _ in writable_files:
         console.print(f"  {target_path}")
+    if reused_paths:
+        console.print("\n[bold]Reused existing files:[/]")
+        for target_path in reused_paths:
+            console.print(f"  {target_path}")
     if skipped_config_paths:
         console.print("\n[bold yellow]Skipped existing config files:[/]")
         for target_path in skipped_config_paths:
@@ -167,7 +206,9 @@ def _resolve_template_args(
     if lang_or_template_id in KNOWN_TEMPLATE_LANGS:
         return lang_or_template_id, template_id
     if template_id is not None:
-        console.print(f"[bold red]Error:[/] Unknown template language: {lang_or_template_id}")
+        console.print(
+            f"[bold red]Error:[/] Unknown template language: {lang_or_template_id}"
+        )
         console.print("Supported languages: node, python")
         raise typer.Exit(1)
     return None, lang_or_template_id
@@ -233,6 +274,11 @@ def _render_template_file(
         console.print(f"[bold red]Error:[/] Source file not found: {source_file}")
         raise typer.Exit(1)
 
+    if template_file.raw:
+        code = source_file.read_text()
+        code = _interpolate_code(code, variables)
+        return _apply_raw_transforms(code, template_file, variables)
+
     markdown = source_file.read_text()
     code_blocks = _extract_code_blocks(markdown, template_file.language)
 
@@ -244,6 +290,32 @@ def _render_template_file(
     return _interpolate_code(code, variables)
 
 
+def _apply_raw_transforms(
+    code: str, template_file: TemplateFile, variables: dict[str, str]
+) -> str:
+    """Rewrite project-specific paths/imports in raw chat scaffold files."""
+    subdir = template_file.source_subdir
+    filename = template_file.source_filename
+    name_kebab = variables.get("name_kebab", "")
+
+    # The chat thread reuses the sibling standalone virtual-list component.
+    if subdir.endswith("chat/thread") and filename == "ChatThread.tsx":
+        code = code.replace("from '../virtual-list'", "from '../../virtual-list'")
+
+    # The chat barrel must not re-export the reused virtual-list package.
+    if subdir.endswith("js_special_files/chat") and filename == "index.ts":
+        code = code.replace("export * from './virtual-list';\n", "")
+
+    # Documentation references to the originating project should be templated.
+    if filename.endswith(".md"):
+        code = code.replace("packages/huddle-ui", f"packages/node/{name_kebab}-ui")
+        code = code.replace("packages/sb/", f"packages/node/{name_kebab}-sb/")
+        code = code.replace("@huddle/ui", f"@{name_kebab}/ui")
+        code = code.replace("huddle-ui", f"{name_kebab}-ui")
+
+    return code
+
+
 def _interpolate_code(code: str, variables: dict[str, str]) -> str:
     code = interpolate(code, variables)
     name_val = variables.get("name", "")
@@ -255,6 +327,76 @@ def _interpolate_code(code: str, variables: dict[str, str]) -> str:
     return code
 
 
+def _update_root_index(
+    ctx: RunContext,
+    written_targets: list[Path],
+    variables: dict[str, str],
+    output_dir: str | None,
+) -> None:
+    """Add component barrel exports to the UI package root index when present."""
+    if output_dir:
+        return
+
+    component_names: list[str] = []
+    for target in written_targets:
+        parts = target.parts
+        if "components" in parts:
+            index = parts.index("components")
+            if index + 1 < len(parts):
+                name = parts[index + 1]
+                if name not in component_names:
+                    component_names.append(name)
+    if not component_names:
+        return
+
+    index_rel = interpolate("packages/node/{name_kebab}-ui/src/index.ts", variables)
+    index_path = ctx.project_dir / index_rel
+    if not index_path.exists():
+        return
+
+    existing = index_path.read_text()
+    additions = [
+        f'export * from "./components/{name}";'
+        for name in sorted(component_names)
+        if f'"./components/{name}"' not in existing
+    ]
+    if not additions:
+        return
+
+    updated = existing.rstrip("\n") + "\n" + "\n".join(additions) + "\n"
+    ctx.write_file(index_path, updated)
+
+
+def _maybe_install_dependencies(
+    ctx: RunContext,
+    ordered_entries: list[tuple[TemplateEntry, bool]],
+    include_tests: bool,
+    install: bool | None,
+) -> None:
+    install_by_default = any(entry.install_by_default for entry, _ in ordered_entries)
+    should_install = install_by_default if install is None else install
+    if not should_install:
+        return
+
+    runtime: list[str] = []
+    dev: list[str] = []
+    for entry, _ in ordered_entries:
+        for dep in entry.dependencies:
+            if dep not in runtime:
+                runtime.append(dep)
+        if include_tests:
+            for dep in entry.dev_dependencies:
+                if dep not in dev:
+                    dev.append(dep)
+
+    if runtime:
+        console.print("\n[bold]Installing runtime dependencies...[/]")
+        ctx.run_command(["npm", "i", *runtime], cwd=ctx.project_dir)
+    if dev:
+        console.print("\n[bold]Installing dev dependencies...[/]")
+        ctx.run_command(["npm", "i", "-D", *dev], cwd=ctx.project_dir)
+
+
 def _resolve_target_path(
     ctx: RunContext,
     template_file: TemplateFile,
@@ -295,4 +437,4 @@ def _find_source_dir(config: SyncConfig) -> Path | None:
     if common.exists():
         return common
 
-    return None
+    return None

{rpr_cli-0.1.26 → rpr_cli-0.1.27}/src/rpr/commands/generate/ui.py

@@ -102,9 +102,17 @@ def ui(
     if include_library:
         console.print("  Optional templates: rpr add template node fetch_service")
         console.print("                      rpr add template node sticky_navigation")
-        console.print("                      rpr add template node sticky_navigation --include-tests")
+        console.print(
+            "                      rpr add template node sticky_navigation --include-tests"
+        )
         console.print("                      rpr add template node virtual_list")
-        console.print("                      rpr add template node virtual_list --include-tests")
+        console.print(
+            "                      rpr add template node virtual_list --include-tests"
+        )
+        console.print("                      rpr add template node chat")
+        console.print(
+            "                      rpr add template node chat --include-tests"
+        )
 
 
 def _scaffold_ui_library(ctx: RunContext, ui_pkg_name: str) -> None:

rpr_cli-0.1.27/src/rpr/scaffolds/js_special_files/chat/README.md

@@ -0,0 +1,349 @@
+# Portable Chat UI
+
+The `chat` directory is intended to be portable UI infrastructure. A consumer should be able to copy this directory into another React/MUI app, install the listed dependencies, inject an app-specific stream client, and get the same thread, composer, file attachment, and streaming behavior.
+
+## What Is Included
+
+- `thread` renders messages, content blocks, files, media, Markdown, HTML, math, code fences, avatars, and streaming chunks.
+- `composer` renders the text/file input surface, native drag-and-drop handling, MUI file-icon attachments, generic trigger suggestions, send, and cancel controls.
+- `client` defines the tiny injected streaming-client contract used by the composer hook.
+- `testing` provides a deterministic mock streaming client for Storybook and unit tests.
+- `virtual-list` keeps large message threads efficient.
+
+The chat package should not import app-specific services, routes, auth state, stores, or generated API code directly.
+
+## Dependencies
+
+Install the UI/runtime dependencies used by this package:
+
+```sh
+npm install @mui/material@latest @mui/icons-material@latest @emotion/react@latest @emotion/styled@latest
+npm install dompurify react-markdown remark-gfm remark-math rehype-katex katex prism-react-renderer
+```
+
+The current project uses MUI 9. Keep MUI system styling in `sx` on MUI components because direct system props can leak to the DOM or fail generated declaration types in MUI 9.
+
+## API Service Boundary
+
+The portable chat package consumes a `ChatStreamClient`. It does not own `fetch`, auth tokens, backend URLs, or generated API-service code.
+
+Apps can generate a fetch service outside the chat folder with:
+
+```sh
+rpr add template node fetch_service --output-dir ./
+```
+
+Then wrap that generated service with the portable interface:
+
+```ts
+import type { ChatStreamClient } from '@huddle/ui';
+
+export const chatStreamClient: ChatStreamClient = {
+  async send(request) {
+    // POST request.text, request.attachments, request.threadId, and metadata.
+    // The backend converts the request to SSE.
+    // The adapter parses SSE events and yields ChatMessageChunkDto objects.
+    return parseSseResponseAsChatChunks(response, request.signal);
+  },
+};
+```
+
+Use JSON for text-only requests when that fits the backend. Use `FormData` when files are present. The generated `api.service.ts` shown in this repo JSON-stringifies `post` bodies, so a real file upload adapter should add a multipart or raw `fetch` path instead of forcing `File` objects through JSON.
+
+## Thread Ownership
+
+`threadId` should normally be owned by the parent conversation controller, not by the composer. The composer hook can create and expose an active id when one is not provided, but selecting an old conversation, creating a new conversation, and managing multiple thread ids belongs above the portable chat package.
+
+Recommended ownership:
+
+- Parent app owns conversation selection and persistence.
+- `useChatStream` accepts `threadId` and reports `activeThreadId`.
+- The stream client sends the active id to the backend with each request.
+
+## Composer Lifecycle
+
+The composer supports text, file attachments, suggestions, send, and cancel.
+
+1. User types a message or adds files.
+2. User presses Enter or clicks send.
+3. `useChatStream` appends an optimistic user message.
+4. The send button becomes a stable-size progress ring with a stop icon inside.
+5. The injected client sends the request with an `AbortSignal`.
+6. SSE chunks are normalized to `ChatMessageChunkDto` and merged with `mergeChatMessageChunk`.
+7. Clicking stop calls `cancel`, aborts the current request, and finalizes the visible partial response.
+
+Use Shift+Enter for new lines. Enter sends when there is draft content.
+
+The composer uses the full available width on mobile and a centered viewport width on larger screens: `width: { xs: '100%', sm: '80vw' }`, `maxWidth: '100%'`, `mx: 'auto'`, and `alignSelf: 'center'`. Override it at any time with `sx`:
+
+```tsx
+<ChatComposer status={chat.status} onSend={chat.send} onCancel={chat.cancel} sx={{ width: { xs: '100%', sm: '72vw', lg: '900px' } }} />
+```
+
+File attachments in the composer use MUI file icons rather than pills. Current categories include PDF, image, video, audio, spreadsheet, code, text, document, and generic file.
+
+## MUI Theming
+
+Chat text is rendered through MUI primitives so app themes can control typography and color. Plain text uses `Typography`, Markdown text maps paragraphs/headings to `Typography`, Markdown links use MUI `Link`, and file labels use MUI text variants.
+
+Use the MUI theme palette for semantic message states instead of hardcoded colors. Text content can opt into `tone: 'error'` or `tone: 'warning'`; message rows with `status: 'error'` render their text with `theme.palette.error.main`. System messages use `text.secondary`, and links use `primary.main`.
+
+## Suggestion System
+
+`ChatComposer` supports generic trigger suggestions through injected providers. The portable chat package does not assume suggestions are users; each provider can return people, files, repos, tickets, symbols, or any app-specific entity.
+
+```tsx
+import type { ChatSuggestionProvider } from '@huddle/ui';
+
+const peopleProvider: ChatSuggestionProvider = {
+  id: 'people',
+  label: 'People',
+  trigger: '@',
+  async getSuggestions({ query, signal }) {
+    const response = await fetch(`/api/people?q=${encodeURIComponent(query)}`, { signal });
+    return response.json();
+  },
+};
+
+<ChatComposer status={chat.status} onSend={chat.send} onCancel={chat.cancel} suggestionsConfig={{ providers: [peopleProvider] }} />;
+```
+
+Multiple providers can share the same trigger. For example, `@` can search both people and files, and the popover groups results by provider label.
+
+Suggestion items separate visible text from backend context:
+
+```ts
+{
+  id: 'user-avery',
+  displayValue: 'Avery Lee',
+  insertValue: '@Avery Lee',
+  description: 'Product lead',
+  payload: { type: 'user', userId: 'user-avery' },
+}
+```
+
+The composer inserts people and other text-backed selections directly into the text field and stores a hidden mention DTO in `draft.mentions`. `useChatStream` forwards those values to the injected `ChatStreamClient` as `request.mentions`, so the backend can receive stable ids and payloads without parsing display text.
+
+Supported controls:
+
+- typing a trigger opens a loading popover next to the composer input
+- further typing calls providers again with the new query
+- Up and Down move the highlighted result
+- Enter or Tab selects the highlighted result while the popover is open
+- Escape closes the popover
+- clicking a result selects it
+- clicking outside closes it
+- whitespace closes normal single-token mention queries
+
+Useful configuration knobs include `debounceMs`, `maxSuggestions`, `closeOnEmptyResults`, `appendSpaceOnSelect`, `popupSx`, and `renderSuggestion`.
+
+File suggestions can opt into the same attachment path as drag/drop by providing real browser file data and a resolver:
+
+```tsx
+<ChatComposer
+  onSend={chat.send}
+  suggestionsConfig={{
+    providers: [filesProvider],
+    getAttachmentFromSuggestion: (item) => {
+      const payload = item.payload as { file?: File } | undefined;
+      return payload?.file;
+    },
+  }}
+/>
+```
+
+The resolver may return a `File`, `{ file }`, or `{ blob, name, mimeType, lastModified }`. When a suggestion resolves to a real file, the composer attaches the file and keeps the inserted text reference so the backend can see where the file was referenced in the message. Path-only suggestions, such as `{ path: 'docs/roadmap.md' }`, are metadata references; they are not equivalent to a dropped file unless the app resolves them to a real `File` or `Blob`. Selected suggestions still store mention metadata, so submitted user messages can render selected people inline and the backend can receive stable ids and ranges in `request.mentions`.
+
+### Built-In Local File Suggestions
+
+The portable chat package includes a frontend-only local file suggestion provider. It indexes a user-selected folder, ranks files for `@` suggestions, and attaches selected suggestions as real browser `File` objects.
+
+```tsx
+import { ChatComposer, LocalFileSuggestionAction, useLocalFileSuggestionProvider, type UseChatStreamResult } from '@huddle/ui';
+
+function ChatInput({ chat }: { chat: UseChatStreamResult }) {
+  const fileSuggestions = useLocalFileSuggestionProvider({ maxIndexedFiles: 1500 });
+
+  return (
+    <ChatComposer
+      status={chat.status}
+      onSend={chat.send}
+      onCancel={chat.cancel}
+      actionButtons={<LocalFileSuggestionAction fileSuggestions={fileSuggestions} />}
+      suggestionsConfig={{
+        providers: [fileSuggestions.provider],
+        getAttachmentFromSuggestion: (item) => {
+          const payload = item.payload as { file?: File } | undefined;
+          return payload?.file;
+        },
+      }}
+    />
+  );
+}
+```
+
+The browser cannot silently index the user's home directory on first load. The local file provider stores the last granted directory handle in IndexedDB and reuses it when the browser still has read permission. If permission needs a user gesture, `LocalFileSuggestionAction` prompts from the composer toolbar. Common generated and system entries such as `node_modules`, `.git`, `.DS_Store`, `Thumbs.db`, and `System Volume Information` are skipped by default, and per-entry read errors are skipped so one protected file does not fail the whole index.
+
+### Composer Toolbar Actions
+
+`ChatComposer` accepts `actionButtons?: React.ReactNode`. The prop name is plural because the node can be one icon button, an array, or a fragment containing multiple provider-specific actions.
+
+```tsx
+<ChatComposer
+  onSend={chat.send}
+  actionButtons={
+    <>
+      <LocalFileSuggestionAction fileSuggestions={fileSuggestions} />
+      <RepoSuggestionAction provider={repoProvider} />
+      <TicketSuggestionAction provider={ticketProvider} />
+    </>
+  }
+  suggestionsConfig={{ providers: [fileSuggestions.provider, repoProvider, ticketProvider] }}
+/>
+```
+
+Each action component should own its own icon button, tooltip, disabled state, dialogs, hidden inputs, and provider-specific setup logic. `ChatComposer` only decides where toolbar actions render; it does not know what each suggestion provider needs to configure itself.
+
+Custom providers follow the same pattern: expose a provider for `suggestionsConfig.providers`, then optionally expose a toolbar action when the provider needs user setup.
+
+```tsx
+const docsProvider: ChatSuggestionProvider = {
+  id: 'docs',
+  label: 'Docs',
+  trigger: '@',
+  async getSuggestions({ query, signal }) {
+    return searchDocs(query, { signal });
+  },
+};
+
+function DocsSuggestionAction() {
+  return (
+    <Tooltip title="Configure docs search">
+      <IconButton size="small" aria-label="Configure docs search">
+        <ManageSearchIcon fontSize="small" />
+      </IconButton>
+    </Tooltip>
+  );
+}
+```
+
+## Latest Message Auto Scroll
+
+`ChatThread` can scroll the latest message into view when messages change. This intentionally scrolls to the beginning of the newest message, which is better for assistant responses because the user lands at the top of the reply instead of the bottom of a growing stream.
+
+```tsx
+<ChatThread messages={chat.messages} autoScrollToLatest />
+```
+
+Defaults are `behavior: 'smooth'` and `block: 'start'`. Override them when needed:
+
+```tsx
+<ChatThread messages={chat.messages} autoScrollToLatest autoScrollBehavior="auto" autoScrollBlock="nearest" />
+```
+
+## Native File Drag And Drop
+
+The composer intentionally uses browser APIs directly instead of a drag/drop library.
+
+The implementation uses:
+
+- `dragenter`, `dragover`, `dragleave`, and `drop` for drop-zone state.
+- `DataTransferItemList` for dropped items.
+- `DataTransferItem.getAsFileSystemHandle()` when available for the modern File System Access API path.
+- `DataTransferItem.getAsFile()` and `DataTransfer.files` as broad fallbacks.
+- A hidden `<input type="file" multiple>` for keyboard access and browser fallback.
+
+Attachment handling should dedupe files by `name`, `size`, and `lastModified`. Image object URLs must be revoked when removed, cleared, or unmounted. Directory drops are optional: support file handles when available, skip unsupported directories, and expose skipped items through a callback so the app can show a snackbar or inline note.
+
+## Hook Usage
+
+Prefer the object-returning API because it can grow without tuple churn:
+
+```tsx
+const chat = useChatStream({
+  client: chatStreamClient,
+  threadId,
+  userName: currentUser.name,
+  userAvatar: currentUser.avatar,
+});
+
+return (
+  <>
+    <ChatThread messages={chat.messages} />
+    <ChatComposer status={chat.status} onSend={chat.send} onCancel={chat.cancel} />
+  </>
+);
+```
+
+The earlier tuple idea, `const [send, cancel, threadId] = useChatStream(...)`, is intentionally not the canonical API. The feature needs status, messages, errors, active thread id, and setters, so the object API stays clearer.
+
+## Mock Client
+
+Use `createMockChatStreamClient` in Storybook and tests. It returns deterministic variable-length Markdown, code, math, and attachment-aware responses without a backend.
+
+```tsx
+const client = createMockChatStreamClient({ chunkDelayMs: 200, seed: 9 });
+const chat = useChatStream({ client, createThreadId: () => 'storybook-thread' });
+```
+
+Use `createMockSuggestionProvider` to demo or test trigger suggestions without a search backend:
+
+```tsx
+const providers = [createMockSuggestionProvider({ id: 'people', label: 'People' })];
+
+<ChatComposer onSend={chat.send} suggestionsConfig={{ providers }} />;
+```
+
+## Testing Expectations
+
+Required coverage for the full chat experience:
+
+- composer text input and Enter-to-send behavior
+- native dropped files through `DataTransferItemList`
+- picker fallback through hidden file input
+- unsupported directory-drop fallback behavior
+- attachment dedupe and object URL cleanup
+- optimistic user message append
+- streamed assistant chunk merge and finalization
+- cancel/abort behavior
+- trigger suggestion loading, keyboard navigation, selection, outside-click close, and hidden mention payloads
+- multiple thread id isolation
+- error handling and retry affordances
+- render performance boundaries
+
+Performance tests should verify:
+
+- typing in the composer does not rerender old thread rows
+- drag hover state only rerenders the composer/drop zone
+- attachment changes do not rerender old messages
+- sending a new message appends only the new user row
+- streaming chunks rerender only the active assistant row
+
+## Storybook Expectations
+
+Stories should include:
+
+- text-only send
+- native drag/drop attachments
+- picker attachments
+- slow cancellable stream
+- `@` suggestions with one provider and multiple providers
+- long Markdown/code/math responses
+- error/retry state
+- dark mode
+- multiple thread ids
+
+Current interactive stories live in `packages/sb/src/lib/huddle-ui/ChatComposer.stories.tsx`.
+
+## Verification
+
+Run these commands after changing the portable chat package:
+
+```sh
+npx nx test huddle-ui
+npx nx build huddle-ui
+npx nx build-storybook sb
+npx nx storybook sb --port 6006
+```
+
+For portability, copy only `packages/huddle-ui/src/lib/chat` into a scratch React/MUI app and confirm no imports point back to the repo-specific `api.service.ts`.

rpr_cli-0.1.27/src/rpr/scaffolds/js_special_files/chat/client/index.ts

@@ -0,0 +1 @@
+export * from './types';

rpr_cli-0.1.27/src/rpr/scaffolds/js_special_files/chat/client/types.ts

@@ -0,0 +1,45 @@
+import type { ChatMessageChunkDto, ChatMessageDto } from '../thread';
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export type ChatStreamAttachmentInput = {
+  id: string;
+  file: File;
+  name: string;
+  mimeType?: string;
+  size: number;
+  lastModified: number;
+};
+
+export type ChatStreamMentionInput = {
+  id: string;
+  providerId: string;
+  providerLabel?: string;
+  trigger: string;
+  displayValue: string;
+  insertValue: string;
+  description?: string;
+  avatarUrl?: string;
+  entityType?: string;
+  range?: {
+    start: number;
+    end: number;
+  };
+  payload?: unknown;
+};
+
+export type ChatStreamSendRequest = {
+  threadId: string;
+  message: ChatMessageDto;
+  text: string;
+  attachments: readonly ChatStreamAttachmentInput[];
+  mentions: readonly ChatStreamMentionInput[];
+  signal: AbortSignal;
+  metadata?: Record<string, unknown>;
+};
+
+export type ChatStreamClient = {
+  send: (
+    request: ChatStreamSendRequest
+  ) => MaybePromise<AsyncIterable<ChatMessageChunkDto>>;
+};