@aprovan/patchwork-editor 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,331 @@
+import { Node } from '@tiptap/core';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Compiler, VirtualProject, VirtualFile, VFSStore } from '@aprovan/patchwork-compiler';
+import { ReactNode } from 'react';
+import { ClassValue } from 'clsx';
+
+declare const CodeBlockExtension: Node<any, any>;
+
+interface CodePreviewProps {
+    code: string;
+    compiler: Compiler | null;
+    /** Available service namespaces for widget calls */
+    services?: string[];
+    /** Optional file path from code block attributes (e.g., "components/calculator.tsx") */
+    filePath?: string;
+}
+declare function CodePreview({ code: originalCode, compiler, services, filePath }: CodePreviewProps): react_jsx_runtime.JSX.Element;
+
+interface MarkdownEditorProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: () => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function MarkdownEditor({ value, onChange, onSubmit, placeholder, disabled, className, }: MarkdownEditorProps): react_jsx_runtime.JSX.Element;
+
+interface ServiceInfo {
+    name: string;
+    namespace: string;
+    procedure: string;
+    description: string;
+    parameters: {
+        jsonSchema: Record<string, unknown>;
+    };
+}
+interface ServicesInspectorProps {
+    namespaces: string[];
+    services?: ServiceInfo[];
+    /** Custom badge component for rendering the service count */
+    BadgeComponent?: React.ComponentType<{
+        children: React.ReactNode;
+        variant?: string;
+        className?: string;
+    }>;
+    /** Custom collapsible components */
+    CollapsibleComponent?: React.ComponentType<{
+        children: React.ReactNode;
+        defaultOpen?: boolean;
+        className?: string;
+    }>;
+    CollapsibleTriggerComponent?: React.ComponentType<{
+        children: React.ReactNode;
+        className?: string;
+    }>;
+    CollapsibleContentComponent?: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+    /** Custom dialog components */
+    DialogComponent?: React.ComponentType<{
+        children: React.ReactNode;
+        open?: boolean;
+        onOpenChange?: (open: boolean) => void;
+    }>;
+    DialogHeaderComponent?: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+    DialogContentComponent?: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+    DialogCloseComponent?: React.ComponentType<{
+        onClose?: () => void;
+    }>;
+}
+declare function ServicesInspector({ namespaces, services, BadgeComponent, DialogComponent, }: ServicesInspectorProps): react_jsx_runtime.JSX.Element | null;
+
+interface EditHistoryEntry {
+    prompt: string;
+    summary: string;
+    isRetry?: boolean;
+}
+interface EditSessionState {
+    project: VirtualProject;
+    originalProject: VirtualProject;
+    activeFile: string;
+    history: EditHistoryEntry[];
+    isApplying: boolean;
+    error: string | null;
+    streamingNotes: string[];
+    pendingPrompt: string | null;
+}
+interface EditSessionActions {
+    submitEdit: (prompt: string) => Promise<void>;
+    revert: () => void;
+    updateActiveFile: (content: string) => void;
+    setActiveFile: (path: string) => void;
+    clearError: () => void;
+}
+declare function getActiveContent(state: EditSessionState): string;
+declare function getFiles(project: VirtualProject): VirtualFile[];
+interface EditRequest {
+    code: string;
+    prompt: string;
+}
+interface EditResponse {
+    newCode: string;
+    summary: string;
+    progressNotes: string[];
+}
+interface CompileResult {
+    success: boolean;
+    error?: string;
+}
+type CompileFn = (code: string) => Promise<CompileResult>;
+
+interface EditApiOptions {
+    endpoint?: string;
+    onProgress?: (note: string) => void;
+    /** Automatically remove stray diff markers from output (default: true) */
+    sanitize?: boolean;
+}
+declare function sendEditRequest(request: EditRequest, options?: EditApiOptions): Promise<EditResponse>;
+
+interface UseEditSessionOptions {
+    originalCode: string;
+    compile?: CompileFn;
+    apiEndpoint?: string;
+}
+declare function useEditSession(options: UseEditSessionOptions): EditSessionState & EditSessionActions;
+
+interface EditHistoryProps {
+    entries: EditHistoryEntry[];
+    streamingNotes: string[];
+    isStreaming: boolean;
+    pendingPrompt?: string | null;
+    className?: string;
+}
+declare function EditHistory({ entries, streamingNotes, isStreaming, pendingPrompt, className, }: EditHistoryProps): react_jsx_runtime.JSX.Element;
+
+interface EditModalProps extends UseEditSessionOptions {
+    isOpen: boolean;
+    onClose: (finalCode: string, editCount: number) => void;
+    renderPreview: (code: string) => ReactNode;
+    renderLoading?: () => ReactNode;
+    renderError?: (error: string) => ReactNode;
+    previewError?: string | null;
+    previewLoading?: boolean;
+}
+declare function EditModal({ isOpen, onClose, renderPreview, renderLoading, renderError, previewError, previewLoading, ...sessionOptions }: EditModalProps): react_jsx_runtime.JSX.Element | null;
+
+interface FileTreeProps {
+    files: VirtualFile[];
+    activeFile: string;
+    onSelectFile: (path: string) => void;
+}
+declare function FileTree({ files, activeFile, onSelectFile }: FileTreeProps): react_jsx_runtime.JSX.Element;
+
+type TextPart = {
+    type: 'text';
+    content: string;
+};
+type CodePart = {
+    type: 'code' | string;
+    content: string;
+    language: 'jsx' | 'tsx' | string;
+    attributes?: Record<string, string>;
+};
+type ParsedPart = TextPart | CodePart;
+interface ExtractOptions {
+    /** Only extract these languages (default: all) */
+    filterLanguages?: Set<string>;
+    /** Include unclosed code blocks at the end (for streaming) */
+    includeUnclosed?: boolean;
+}
+/**
+ * Extract code blocks from markdown text.
+ */
+declare function extractCodeBlocks(text: string, options?: ExtractOptions): ParsedPart[];
+/**
+ * Find the first JSX/TSX block in the text.
+ * Returns null if no JSX block is found.
+ */
+declare function findFirstCodeBlock(text: string): CodePart | null;
+/**
+ * Check if text contains any JSX/TSX code blocks.
+ */
+declare function hasCodeBlock(text: string): boolean;
+/**
+ * Get all unique languages found in code blocks.
+ */
+declare function getCodeBlockLanguages(text: string): Set<string>;
+/**
+ * Extract code blocks as a VirtualProject.
+ * Groups files with path attributes into a multi-file project.
+ * Files without paths are treated as the main entry file.
+ */
+declare function extractProject(text: string, options?: ExtractOptions): {
+    project: VirtualProject;
+    textParts: TextPart[];
+};
+
+interface CodeBlockAttributes {
+    /** Progress note for UI display (optional but encouraged, comes first) */
+    note?: string;
+    /** Virtual file path for multi-file generation (uses \@/ prefix) */
+    path?: string;
+    /** Additional arbitrary attributes */
+    [key: string]: string | undefined;
+}
+interface CodeBlock {
+    /** Language identifier (e.g., tsx, json, diff) */
+    language: string;
+    /** Parsed attributes from the fence line */
+    attributes: CodeBlockAttributes;
+    /** Raw content between the fence markers */
+    content: string;
+}
+interface DiffBlock {
+    search: string;
+    replace: string;
+    /** Progress note from the code fence attributes */
+    note?: string;
+    /** Target file path for multi-file edits */
+    path?: string;
+}
+/**
+ * Parse attributes from a code fence line.
+ *
+ * Example input: 'note="Adding handler" path="\@/components/Button.tsx"'
+ *
+ * Returns: an object with note, path, and any other attributes
+ */
+declare function parseCodeBlockAttributes(attrString: string): CodeBlockAttributes;
+/**
+ * Parse all code blocks from text, extracting language and attributes.
+ * Returns blocks in order of appearance.
+ */
+declare function parseCodeBlocks(text: string): CodeBlock[];
+/**
+ * Check if text contains any diff markers.
+ * Returns the first marker found, or null if clean.
+ */
+declare function findDiffMarkers(text: string): string | null;
+/**
+ * Remove stray diff markers from text.
+ * Use as a fallback when markers leak into output.
+ */
+declare function sanitizeDiffMarkers(text: string): string;
+interface ParsedEditResponse {
+    /** Progress notes extracted from code block attributes (in order of appearance) */
+    progressNotes: string[];
+    /** Parsed diff blocks with their attributes */
+    diffs: DiffBlock[];
+    /** Summary markdown text (content outside of code blocks) */
+    summary: string;
+}
+/**
+ * Parse progress notes and diffs from an edit response.
+ *
+ * New format uses tagged attributes on code fences:
+ * ```diff note="Adding handler" path="@/components/Button.tsx"
+ * <<<<<<< SEARCH
+ * exact code
+ * =======
+ * replacement
+ * >>>>>>> REPLACE
+ * ```
+ *
+ * Summary markdown is everything outside of code blocks.
+ */
+declare function parseEditResponse(text: string): ParsedEditResponse;
+/**
+ * Parse diff blocks from text, extracting attributes from code fences.
+ * Supports both fenced code blocks with attributes and raw diff markers.
+ */
+declare function parseDiffs(text: string): DiffBlock[];
+declare function applyDiffs(code: string, diffs: DiffBlock[], options?: {
+    sanitize?: boolean;
+}): {
+    code: string;
+    applied: number;
+    failed: string[];
+    warning?: string;
+};
+declare function hasDiffBlocks(text: string): boolean;
+declare function extractTextWithoutDiffs(text: string): string;
+/**
+ * Extract the summary markdown from an edit response.
+ * Removes code blocks (with their attributes), and any leading/trailing whitespace.
+ * Preserves regular markdown prose outside of code blocks.
+ */
+declare function extractSummary(text: string): string;
+
+/**
+ * Get VFS configuration from the server.
+ * Caches the result for subsequent calls.
+ */
+declare function getVFSConfig(): Promise<{
+    usePaths: boolean;
+}>;
+/**
+ * Get the VFS store instance (creates one if needed).
+ * Store uses LocalFSBackend to persist to the stitchery server.
+ */
+declare function getVFSStore(): VFSStore;
+/**
+ * Save a virtual project to disk via the stitchery server.
+ * Projects are saved under their ID in the VFS directory.
+ */
+declare function saveProject(project: VirtualProject): Promise<void>;
+/**
+ * Load a project from disk by ID.
+ */
+declare function loadProject(id: string): Promise<VirtualProject | null>;
+/**
+ * List all stored project IDs.
+ */
+declare function listProjects(): Promise<string[]>;
+/**
+ * Save a single file to the VFS.
+ */
+declare function saveFile(file: VirtualFile): Promise<void>;
+/**
+ * Check if VFS is available (stitchery server is running with vfs-dir enabled).
+ */
+declare function isVFSAvailable(): Promise<boolean>;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { type CodeBlock, type CodeBlockAttributes, CodeBlockExtension, type CodePart, CodePreview, type CompileFn, type CompileResult, type DiffBlock, type EditApiOptions, EditHistory, type EditHistoryEntry, EditModal, type EditModalProps, type EditRequest, type EditResponse, type EditSessionActions, type EditSessionState, type ExtractOptions, FileTree, type FileTreeProps, MarkdownEditor, type ParsedEditResponse, type ParsedPart, type ServiceInfo, ServicesInspector, type TextPart, type UseEditSessionOptions, applyDiffs, cn, extractCodeBlocks, extractProject, extractSummary, extractTextWithoutDiffs, findDiffMarkers, findFirstCodeBlock, getActiveContent, getCodeBlockLanguages, getFiles, getVFSConfig, getVFSStore, hasCodeBlock, hasDiffBlocks, isVFSAvailable, listProjects, loadProject, parseCodeBlockAttributes, parseCodeBlocks, parseDiffs, parseEditResponse, sanitizeDiffMarkers, saveFile, saveProject, sendEditRequest, useEditSession };