stk-codegen 1.0.5 → 1.0.7

package/dist/App.d.ts

@@ -1,2 +1,4 @@
-import React from 'react';
-export declare const App: () => React.JSX.Element;
+import { FC } from 'react';
+export declare const App: FC<{
+    autonomous?: boolean;
+}>;

package/dist/components/BootstrapStatus.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const BootstrapStatus: () => React.JSX.Element;
+export default BootstrapStatus;

package/dist/components/Conversation.d.ts

@@ -1,13 +1,20 @@
-import React from 'react';
-import { ConversationMessage, PendingShellCommand } from '../types/index.js';
+import { FC } from 'react';
 import { ChildProcess } from 'child_process';
+import { DiffReviewView, ShellRunView, StaticMessageView } from "../ui/agent/buildInkViewModel.js";
 interface ConversationProps {
-    conversation: ConversationMessage[];
-    activeShellCommand: any;
+    messages: StaticMessageView[];
+    liveAgentMessage?: StaticMessageView;
+    activeShellRun?: ShellRunView;
+    activeDiffReview?: DiffReviewView;
+    onShellComplete: (result: {
+        stdout: string;
+        stderr: string;
+        exitCode: number | null;
+    }) => void;
     childProcess: ChildProcess | null;
-    handleShellCompletion: (result: any) => void;
-    pendingShellCommand: PendingShellCommand | null;
-    isFullReviewView: boolean;
+    sendInputToShell: (input: string) => void;
+    onApproveDiff: (editedContent?: string) => void;
+    onRejectDiff: () => void;
 }
-export declare const Conversation: React.FC<ConversationProps>;
+export declare const Conversation: FC<ConversationProps>;
 export {};

package/dist/components/DiffView.d.ts

@@ -2,13 +2,20 @@ import React from 'react';
 export interface DiffViewStaticProps {
     oldContent: string;
     newContent: string;
-    filePath: string;
+    filePath?: string;
+    toolName?: string;
+    toolParams?: Record<string, any>;
     isCompleted: boolean;
     action?: string;
     maxVisibleLines?: number;
 }
 interface DiffViewProps extends DiffViewStaticProps {
-    onComplete?: (action: 'accept' | 'reject' | 'edit', editedContent?: string) => void;
+    onApprove: (editedContent?: string) => void;
+    onReject: () => void;
+    coreDiffReview?: {
+        id: string;
+        status: 'pending' | 'accepted' | 'rejected';
+    };
 }
 export declare const DiffDecisionHint: React.FC;
 export declare const DiffViewStatic: React.FC<DiffViewStaticProps>;

package/dist/components/Input.d.ts

@@ -2,12 +2,18 @@ import React from 'react';
 interface Props {
     value: string;
     onChange: (value: string) => void;
-    onSubmit: (value: string) => void;
+    onSubmit: (value: string, extra?: {
+        images?: {
+            base64: string;
+            mimeType: string;
+        }[];
+    }) => void;
     searchFiles: (pattern: string, options?: {
         ignore?: string[];
     }) => Promise<string[]>;
     isShellActive?: boolean;
     setShowEscapeClear: (show: boolean) => void;
+    isActive: boolean;
 }
-declare const _default: React.MemoExoticComponent<({ value, onChange, onSubmit, searchFiles, isShellActive, setShowEscapeClear, }: Props) => React.JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ value, onChange, onSubmit, searchFiles, isShellActive, setShowEscapeClear, isActive, }: Props) => React.JSX.Element>;
 export default _default;

package/dist/components/Message.d.ts

@@ -6,7 +6,7 @@ interface MessageProps {
     activeShellCommand: any;
     childProcess: ChildProcess | null;
     handleShellCompletion: (result: any) => void;
-    isFullReviewView: boolean;
+    context?: 'static' | 'live';
 }
 export declare const MemoizedMessage: React.NamedExoticComponent<MessageProps>;
 export {};

package/dist/components/ShellConfirmation.d.ts

@@ -1,6 +1,8 @@
 import React from 'react';
 interface ShellConfirmationProps {
     command: string;
+    onApprove: () => void;
+    onReject: () => void;
 }
-declare const ShellConfirmation: ({ command }: ShellConfirmationProps) => React.JSX.Element;
+declare const ShellConfirmation: ({ command, onApprove, onReject }: ShellConfirmationProps) => React.JSX.Element;
 export default ShellConfirmation;

package/dist/components/ShellExecution.d.ts

@@ -4,6 +4,16 @@ interface ShellExecutionProps {
     command: string;
     childProcess: ChildProcess | null;
     onComplete: (result: any) => void;
+    coreShellRun?: {
+        id: string;
+        status: 'pending' | 'running' | 'finished' | 'error' | 'cancelled';
+        stdout: string;
+        stderr: string;
+        visibleOutput?: string;
+        isVisuallyTruncated?: boolean;
+        totalLines?: number;
+        visibleLinesCount?: number;
+    };
 }
 declare const ShellExecution: React.FC<ShellExecutionProps>;
 export default ShellExecution;

package/dist/components/ToolExecution.d.ts

@@ -3,6 +3,7 @@ interface ToolExecutionProps {
     toolName: string;
     displayMessage?: string;
     toolParams?: Record<string, any>;
+    status?: 'running' | 'finished' | 'error' | 'completed' | undefined;
 }
-declare const ToolExecution: ({ toolName, toolParams }: ToolExecutionProps) => React.JSX.Element;
+declare const ToolExecution: ({ toolName, toolParams, status }: ToolExecutionProps) => React.JSX.Element;
 export default ToolExecution;

package/dist/core/agent/events.d.ts

@@ -0,0 +1,66 @@
+import { CoreMessageId, DiffReviewId, ShellRunId } from './types.js';
+export type CoreEvent = {
+    type: 'USER_SENT_MESSAGE';
+    text: string;
+} | {
+    type: 'AGENT_STREAM_STARTED';
+    messageId: CoreMessageId;
+} | {
+    type: 'AGENT_DELTA_RECEIVED';
+    delta: string;
+} | {
+    type: 'AGENT_STREAM_FLUSH';
+} | {
+    type: 'AGENT_STREAM_FINISHED';
+} | {
+    type: 'TOOL_RESULT_MESSAGE';
+    text: string;
+} | {
+    type: 'TOOL_EXECUTION_STARTED';
+    toolId: string;
+    toolName: string;
+    toolParams: Record<string, any>;
+} | {
+    type: 'TOOL_EXECUTION_FINISHED';
+    toolId: string;
+    toolName: string;
+    toolParams: Record<string, any>;
+} | {
+    type: 'TOOL_EXECUTION_ERROR';
+    toolId: string;
+    toolName: string;
+    toolParams: Record<string, any>;
+    error: string;
+} | {
+    type: 'SHELL_RUN_STARTED';
+    runId: ShellRunId;
+    command: string;
+} | {
+    type: 'SHELL_OUTPUT_RECEIVED';
+    runId: ShellRunId;
+    stdoutDelta?: string;
+    stderrDelta?: string;
+} | {
+    type: 'SHELL_RUN_FINISHED';
+    runId: ShellRunId;
+    exitCode: number;
+} | {
+    type: 'DIFF_REVIEW_OPENED';
+    reviewId: DiffReviewId;
+    title?: string;
+    toolName?: string;
+    toolParams?: Record<string, any>;
+    oldContent: string;
+    newContent: string;
+} | {
+    type: 'DIFF_REVIEW_RESOLVED';
+    reviewId: DiffReviewId;
+    result: 'accepted' | 'rejected';
+} | {
+    type: 'ERROR_OCCURRED';
+    message: string;
+} | {
+    type: 'BOOTSTRAP_STARTED';
+} | {
+    type: 'BOOTSTRAP_FINISHED';
+};

package/dist/core/agent/reducer.d.ts

@@ -0,0 +1,4 @@
+import { CoreState } from './types.js';
+import { CoreEvent } from './events.js';
+export declare const initialCoreState: CoreState;
+export declare function reduceCoreState(state: CoreState, event: CoreEvent): CoreState;

package/dist/core/agent/types.d.ts

@@ -0,0 +1,54 @@
+export type CoreRole = 'user' | 'agent' | 'tool_execution' | 'shell' | 'system' | 'agent_error' | 'agent_thought';
+export type CoreMessageId = string;
+export interface CoreMessage {
+    id: CoreMessageId;
+    role: CoreRole;
+    text: string;
+    createdAt: number;
+    isStreaming?: boolean;
+    isFinal?: boolean;
+    toolId?: string;
+    toolName?: string;
+    toolParams?: Record<string, any>;
+    status?: 'running' | 'finished' | 'error';
+    isBootstrap?: boolean;
+}
+export type ShellRunId = string;
+export interface CoreShellRun {
+    id: ShellRunId;
+    command: string;
+    status: 'pending' | 'running' | 'finished' | 'error' | 'cancelled';
+    stdout: string;
+    stderr: string;
+    startedAt?: number;
+    finishedAt?: number;
+}
+export type DiffReviewId = string;
+export interface CoreDiffReview {
+    id: DiffReviewId;
+    title?: string;
+    toolName?: string;
+    toolParams?: Record<string, any>;
+    oldContent: string;
+    newContent: string;
+    status: 'pending' | 'accepted' | 'rejected';
+}
+export interface CoreAgentStatus {
+    label: string;
+    detail?: string;
+    phase: 'idle' | 'thinking' | 'streaming' | 'waiting_tool' | 'running_tool';
+}
+export interface CoreStreamState {
+    currentMessageId?: CoreMessageId;
+    buffer: string;
+    status: 'idle' | 'streaming' | 'finished';
+}
+export interface CoreState {
+    messages: CoreMessage[];
+    shellRuns: CoreShellRun[];
+    diffReviews: CoreDiffReview[];
+    agentStatus: CoreAgentStatus;
+    stream: CoreStreamState;
+    isBootstrapping: boolean;
+    bootstrapFinished: boolean;
+}

package/dist/hooks/useAgent.core.d.ts

@@ -0,0 +1,16 @@
+import { CoreEvent } from '../core/agent/events.js';
+import { CoreState } from '../core/agent/types.js';
+import { InkViewModel } from '../ui/agent/buildInkViewModel.js';
+export interface UseAgentCoreResult {
+    coreState: CoreState;
+    dispatchCore: (event: CoreEvent) => void;
+    viewModel: InkViewModel;
+}
+/**
+ * Hook fino, sem dependência de Ink, que expõe o core de agente e um view model básico.
+ *
+ * A ideia é que `useAgent` (hook principal usado pela UI Ink) passe a delegar
+ * estado de domínio para este hook, mantendo apenas integração com backend,
+ * teclado e ferramentas.
+ */
+export declare function useAgentCore(): UseAgentCoreResult;

package/dist/hooks/useAgent.d.ts

@@ -1,7 +1,8 @@
 import { ChildProcess } from 'child_process';
-import { ConversationMessage, PendingShellCommand } from '../types/index.js';
-export declare const useAgent: () => {
-    conversation: ConversationMessage[];
+import { PendingShellCommand } from '../types/index.js';
+export declare const useAgent: ({ autonomous }: {
+    autonomous?: boolean;
+}) => {
     agentStatus: {
         isVisible: boolean;
         text: string;
@@ -11,14 +12,25 @@ export declare const useAgent: () => {
     rejectShellCommand: () => void;
     approveDiff: (editedContent?: string) => void;
     rejectDiff: () => void;
-    submitUserInput: (text: string) => void;
+    submitUserInput: (text: string, extra?: {
+        images?: {
+            base64: string;
+            mimeType: string;
+        }[];
+    }) => void;
     navigateHistoryUp: () => string | undefined;
     navigateHistoryDown: () => string | undefined;
     searchFiles: (pattern: string, options?: {
         ignore?: string[];
     }) => Promise<any>;
     activeShellCommand: any;
-    handleShellCompletion: (result: any) => void;
+    handleShellCompletion: (result: any, meta?: {
+        messageId: number;
+        tool_name: string;
+        tool_id: string;
+        generation_id: string;
+        parameters?: any;
+    }) => void;
     childProcess: ChildProcess | null;
     sendInputToShell: (input: string) => void;
     inputText: string;
@@ -28,5 +40,7 @@ export declare const useAgent: () => {
     resetHistory: () => void;
     cancelCurrentInteraction: () => void;
     activeGenerationId: string | null;
+    coreState: import("../core/agent/types.js").CoreState;
+    coreViewModel: import("../ui/agent/buildInkViewModel.js").InkViewModel;
     hasCodegenSpec: boolean;
 };

package/dist/hooks/useTerminalLayout.d.ts

@@ -1,6 +1,6 @@
 export declare const AGENT_STREAM_RATIO = 0.5;
 export declare const DIFF_REVIEW_RATIO = 0.5;
-export declare const SHELL_OUTPUT_RATIO = 0.7;
+export declare const SHELL_OUTPUT_RATIO = 0.4;
 export declare const FOOTER_RESERVED_LINES = 4;
 export declare const useTerminalLayout: () => {
     readonly rows: any;
@@ -10,7 +10,7 @@ export declare const useTerminalLayout: () => {
     readonly layoutConstants: {
         readonly AGENT_STREAM_RATIO: 0.5;
         readonly DIFF_REVIEW_RATIO: 0.5;
-        readonly SHELL_OUTPUT_RATIO: 0.7;
+        readonly SHELL_OUTPUT_RATIO: 0.4;
         readonly FOOTER_RESERVED_LINES: 4;
     };
 };