@pheem49/mint 1.8.0 → 1.8.2

package/src/renderer/src/tauri.ts

@@ -1,115 +1,46 @@
-export interface RuntimeStatus {
-  backend: string
-  configPath: string
-  activeProvider: string
-  availableProviders: string[]
-  integrations: Record<string, unknown>
-}
+/** Returns true when running inside the Tauri webview (desktop app). */
+export const isTauriRuntime = (): boolean =>
+  typeof window !== 'undefined' && Boolean((window as any).__TAURI_INTERNALS__)
 
-export interface ChatResponse {
-  provider: string
-  model: string
-  text: string
-  fallbackProvider?: string | null
+/**
+ * Returns the local API base URL.
+ * Uses the current hostname so LAN access (e.g. from another device) works correctly.
+ * Mirrors the same helper in src-web/tauri.ts.
+ */
+export const getLocalApiBase = (): string => {
+  const host = typeof window !== 'undefined' ? window.location.hostname : 'localhost'
+  return `http://${host}:3000/api`
 }
 
-export interface TtsUrl {
-  shortText: string
-  url: string
-}
+export * from '../shared/types'
+import type { MintPlatformApi } from '../shared/platform'
+import type {
 
-export interface DocumentAttachment {
-  filename: string
-  dataUri: string
-}
+  RuntimeStatus,
+  ChatResponse,
+  TtsUrl,
+  DocumentAttachment,
+  AgentProgress,
+  InteractionMemory,
+  ChatSession,
+  PictureEntry,
+  ImageGenRequest,
+  ImageGenProviders,
+  ImageGenResponse,
+  WorkspaceTreeEntry,
+  CodeEdit,
+  CodeEditProposal,
+} from '../shared/types'
 
-export type AgentProgress =
-  | { type: 'Thinking'; data: { elapsed_secs: number } }
-  | { type: 'Thought'; data: { thought: string } }
-  | { type: 'ToolStart'; data: { action: string; input: Record<string, unknown> } }
-  | { type: 'ToolEnd'; data: { action: string; input: Record<string, unknown>; result: string } }
 
 type DesktopStreamEvent =
   | { type: 'chunk'; chunk: string }
   | { type: 'progress'; progress: AgentProgress }
 
-export interface InteractionMemory {
-  id: number
-  chatId: string
-  userText: string
-  aiText: string
-  provider: string
-  model: string
-  fallbackProvider?: string | null
-  createdAt: string
-  agentActivity?: AgentProgress[] | null
-}
-
-export interface ChatSession {
-  id: string
-  title: string
-  kind: string
-  createdAt: string
-  updatedAt: string
-}
-
-export interface PictureEntry {
-  id: string
-  filename: string
-  path: string
-  mimeType: string
-  createdAt: string
-  source: string
-  message: string
-  thumbnailPath?: string
-  url?: string
-  thumbnailUrl?: string
-}
-
-export interface ImageGenRequest {
-  prompt: string
-  negativePrompt?: string
-  aspectRatio?: '1:1' | '16:9' | '9:16' | '4:3'
-  numImages?: number
-  model?: string
-  /** Which image generation provider to use. Falls back to config default when omitted. */
-  provider?: string
-}
-
-export interface ImageGenProviders {
-  active: string
-  available: string[]
-}
-
-export interface ImageGenResponse {
-  images: PictureEntry[]
-  model: string
-  provider: string
-  prompt: string
-  description?: string | null
-}
-
-export interface WorkspaceTreeEntry {
-  name: string
-  path: string
-  kind: 'file' | 'directory'
-  children: WorkspaceTreeEntry[]
-}
-
-export interface CodeEdit {
-  path: string
-  content: string
-}
-
-export interface CodeEditProposal {
-  approvalRequired: boolean
-  approvalToken: string
-  edits: Array<{ path: string; existed: boolean; diff: string }>
-}
 
 export async function getRuntimeStatus(): Promise<RuntimeStatus> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const res = await fetch(`${API_BASE}/status`);
       return await res.json();
@@ -128,6 +59,28 @@ export async function getRuntimeStatus(): Promise<RuntimeStatus> {
   return invoke<RuntimeStatus>('get_runtime_status')
 }
 
+export interface DetectedTools {
+  docker: boolean
+  git: boolean
+  gh: boolean
+  node: boolean
+}
+
+export async function detectSystemTools(): Promise<DetectedTools> {
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
+    try {
+      const res = await fetch(`${API_BASE}/detect-tools`);
+      return await res.json();
+    } catch (e) {
+      console.error("Failed to detect tools from local server:", e);
+      return { docker: false, git: false, gh: false, node: false };
+    }
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke<DetectedTools>('detect_system_tools')
+}
+
 export async function sendChatMessage(
   message: string,
   imageDataUri?: string | null,
@@ -135,15 +88,16 @@ export async function sendChatMessage(
   documentAttachment?: DocumentAttachment | null,
   workspacePath?: string | null,
   chatId?: string | null,
+  agentId?: string | null,
 ): Promise<ChatResponse> {
   const outgoingMessage = withImagePlaceholder(message, imageDataUri)
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const res = await fetch(`${API_BASE}/chat`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment })
+        body: JSON.stringify({ message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment, agentId })
       });
       const data = await res.json().catch(() => null);
       if (!res.ok) {
@@ -164,7 +118,7 @@ export async function sendChatMessage(
   }
   const { invoke } = await import('@tauri-apps/api/core')
   const response = await invoke<ChatResponse>('send_chat_message', {
-    request: { message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath },
+    request: { message: outgoingMessage, systemInstruction: '', chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath, agentId },
   })
   if (imageDataUri) {
     await invoke('save_pictures', {
@@ -186,14 +140,15 @@ export async function streamChatMessage(
   documentAttachment?: DocumentAttachment | null,
   workspacePath?: string | null,
   chatId?: string | null,
+  agentId?: string | null,
 ): Promise<ChatResponse> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     const outgoingMessage = withImagePlaceholder(message, imageDataUri);
     const res = await fetch(`${API_BASE}/chat-stream`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment })
+      body: JSON.stringify({ message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment, agentId })
     });
     if (!res.ok) {
       const data = await res.json().catch(() => null);
@@ -239,7 +194,7 @@ export async function streamChatMessage(
     else onProgress?.(event.progress)
   }
   const response = await invoke<ChatResponse>('stream_chat_message', {
-    request: { message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath },
+    request: { message: outgoingMessage, systemInstruction, chatId, imageDataUri, audioDataUri, documentAttachment, workspacePath, agentId },
     onEvent,
   })
   if (imageDataUri) {
@@ -265,9 +220,23 @@ export async function getTtsUrls(text: string): Promise<TtsUrl[]> {
   return invoke<TtsUrl[]>('get_tts_urls', { text })
 }
 
+export async function cancelChatMessage(chatId: string): Promise<void> {
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
+    await fetch(`${API_BASE}/cancel-chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ chatId })
+    });
+    return;
+  }
+  const { invoke } = await import('@tauri-apps/api/core')
+  await invoke('cancel_chat_message', { chatId })
+}
+
 export async function getRecentInteractions(limit = 50, chatId?: string | null): Promise<InteractionMemory[]> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const params = new URLSearchParams({ limit: String(limit) });
       if (chatId) params.set('chatId', chatId);
@@ -288,8 +257,8 @@ export async function saveSystemInteraction(
   provider: string,
   model: string,
 ): Promise<any> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const res = await fetch(`${API_BASE}/interactions`, {
         method: 'POST',
@@ -310,8 +279,8 @@ export async function saveInteractionAgentActivity(
   interactionId: number,
   activity: AgentProgress[],
 ): Promise<void> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const res = await fetch(`${API_BASE}/interactions/agent-activity`, {
         method: 'POST',
@@ -331,8 +300,8 @@ export async function saveInteractionAgentActivity(
 }
 
 export async function listChatSessions(): Promise<ChatSession[]> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const res = await fetch(`${API_BASE}/chat-sessions`);
       const data = await res.json();
@@ -347,8 +316,8 @@ export async function listChatSessions(): Promise<ChatSession[]> {
 }
 
 export async function deleteChatSession(chatId: string): Promise<number> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const params = new URLSearchParams({ chatId });
       const res = await fetch(`${API_BASE}/chat-sessions/delete?${params.toString()}`, { method: 'POST' });
@@ -364,8 +333,8 @@ export async function deleteChatSession(chatId: string): Promise<number> {
 }
 
 export async function renameChatSession(chatId: string, newTitle: string): Promise<number> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const res = await fetch(`${API_BASE}/chat-sessions/rename`, {
         method: 'POST',
@@ -384,8 +353,8 @@ export async function renameChatSession(chatId: string, newTitle: string): Promi
 }
 
 export async function getProfileValue(key: string): Promise<string> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const params = new URLSearchParams({ key });
       const res = await fetch(`${API_BASE}/profile?${params.toString()}`);
@@ -401,8 +370,8 @@ export async function getProfileValue(key: string): Promise<string> {
 }
 
 export async function setProfileValue(key: string, value: string): Promise<boolean> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const res = await fetch(`${API_BASE}/profile`, {
         method: 'POST',
@@ -426,9 +395,10 @@ export interface LearnedSkill {
   sourcePath: string
   content: string
   updatedAt: string
+  location?: string
 }
 
-export async function listLearnedSkills(): Promise<LearnedSkill[]> {
+export async function listLearnedSkills(workspacePath?: string): Promise<LearnedSkill[]> {
   if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
     try {
       const val = await getProfileValue('learned-skills-web-mock')
@@ -442,7 +412,7 @@ export async function listLearnedSkills(): Promise<LearnedSkill[]> {
     }
   }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke<LearnedSkill[]>('list_learned_skills')
+  return invoke<LearnedSkill[]>('list_learned_skills', { workspacePath })
 }
 
 export async function addLearnedSkill(name: string, content: string): Promise<LearnedSkill> {
@@ -486,8 +456,8 @@ export async function deleteLearnedSkill(name: string): Promise<number> {
 }
 
 export async function clearChatHistory(chatId?: string | null): Promise<number> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const params = new URLSearchParams();
       if (chatId) params.set('chatId', chatId);
@@ -505,14 +475,15 @@ export async function clearChatHistory(chatId?: string | null): Promise<number>
 }
 
 export async function listSavedPictures(): Promise<PictureEntry[]> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
-      const res = await fetch(`${API_BASE}/pictures`);
+      const res = await fetch(`${API_BASE}/pictures?_t=${Date.now()}`);
       const pictures = await res.json();
+      const timestamp = Date.now();
       return Array.isArray(pictures)
         ? pictures.map((picture) => {
-            const pictureUrl = picture.url ? `${API_BASE.replace('/api', '')}${picture.url}` : undefined
+            const pictureUrl = picture.url ? `${API_BASE.replace('/api', '')}${picture.url}?_t=${timestamp}` : undefined
             return {
               ...picture,
               path: pictureUrl || picture.path,
@@ -534,8 +505,8 @@ export async function listSavedPictures(): Promise<PictureEntry[]> {
 export async function generateImages(
   request: ImageGenRequest
 ): Promise<ImageGenResponse> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = 'http://localhost:3000/api'
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase()
     const res = await fetch(`${API_BASE}/image-generate`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -569,8 +540,8 @@ export async function generateImages(
 
 /** Fetch which image-generation providers are currently configured on the backend. */
 export async function getImageGenProviders(): Promise<ImageGenProviders> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = 'http://localhost:3000/api'
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase()
     try {
       const res = await fetch(`${API_BASE}/image-gen/providers`)
       if (res.ok) return await res.json()
@@ -599,8 +570,8 @@ export async function getImageGenProviders(): Promise<ImageGenProviders> {
 
 /** Updates the default image generation provider in the configuration. */
 export async function setDefaultImageProvider(provider: string): Promise<boolean> {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
     try {
       const getRes = await fetch(`${API_BASE}/config`)
       if (!getRes.ok) return false
@@ -647,6 +618,24 @@ export async function getWorkspaceTree(path?: string | null): Promise<WorkspaceT
   return invoke<WorkspaceTreeEntry>('get_workspace_tree', { path })
 }
 
+export async function createWorkspaceFile(path: string): Promise<void> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) return
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('create_workspace_file', { path })
+}
+
+export async function createWorkspaceFolder(path: string): Promise<void> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) return
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('create_workspace_folder', { path })
+}
+
+export async function deleteWorkspaceItem(path: string): Promise<void> {
+  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) return
+  const { invoke } = await import('@tauri-apps/api/core')
+  return invoke('delete_workspace_item', { path })
+}
+
 export async function selectWorkspaceDirectory(): Promise<string | null> {
   if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
     return null
@@ -656,12 +645,12 @@ export async function selectWorkspaceDirectory(): Promise<string | null> {
   return selected?.trim() || null
 }
 
-export async function submitToolApproval(token: string, approved: boolean): Promise<void> {
+export async function submitToolApproval(token: string, approved: boolean, answer?: string): Promise<void> {
   if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
     return;
   }
   const { invoke } = await import('@tauri-apps/api/core')
-  return invoke('submit_tool_approval', { token, approved })
+  return invoke('submit_tool_approval', { token, approved, answer })
 }
 
 export async function proposeCodeEdits(root: string, edits: CodeEdit[]): Promise<CodeEditProposal> {
@@ -701,9 +690,9 @@ export function convertFileSrc(filePath: string, protocol = 'asset'): string {
 }
 
 export function installTauriAdapters() {
-  if (typeof window === 'undefined' || !(window as any).__TAURI_INTERNALS__) {
-    console.warn("Not running inside Tauri. Connecting to local API server fallback at http://localhost:3000/api.");
-    const API_BASE = "http://localhost:3000/api";
+  if (!isTauriRuntime()) {
+    const API_BASE = getLocalApiBase();
+    console.warn(`Not running inside Tauri. Connecting to local API server fallback at ${API_BASE}.`);
 
     (window as any).settingsApi = {
       getSettings: async () => {
@@ -1239,3 +1228,40 @@ export async function readClipboardImage(): Promise<string | null> {
     return null
   }
 }
+
+// Enforce compile-time check against the shared platform interface
+const _apiCheck: MintPlatformApi = {
+  getRuntimeStatus,
+  detectSystemTools,
+  sendChatMessage,
+  streamChatMessage,
+  getTtsUrls,
+  cancelChatMessage,
+  getRecentInteractions,
+  saveSystemInteraction,
+  saveInteractionAgentActivity,
+  listChatSessions,
+  deleteChatSession,
+  renameChatSession,
+  getProfileValue,
+  setProfileValue,
+  listLearnedSkills,
+  addLearnedSkill,
+  deleteLearnedSkill,
+  clearChatHistory,
+  listSavedPictures,
+  generateImages,
+  getImageGenProviders,
+  setDefaultImageProvider,
+  getWorkspaceTree,
+  createWorkspaceFile,
+  createWorkspaceFolder,
+  deleteWorkspaceItem,
+  selectWorkspaceDirectory,
+  submitToolApproval,
+  proposeCodeEdits,
+  applyCodeEdits,
+  listen,
+  readClipboardImage,
+}
+

package/src/renderer/src-web/agentProgress.ts

@@ -1,39 +1,11 @@
-import type { AgentProgress, InteractionMemory } from './tauri'
-
-export function thoughtsFrom(progress: AgentProgress[]): string[] {
-  return progress
-    .filter((event) => event.type === 'Thought')
-    .map((event) => (event as Extract<AgentProgress, { type: 'Thought' }>).data.thought)
-    .filter(Boolean)
-}
-
-export function trimAgentProgress(progress: AgentProgress[], maxNonThought = 20): AgentProgress[] {
-  if (progress.length === 0) return progress
-  const keptNonThought = new Set(
-    progress.filter((event) => event.type !== 'Thought').slice(-maxNonThought),
-  )
-  return progress.filter((event) => event.type === 'Thought' || keptNonThought.has(event))
-}
-
-export function hasAgentToolActivity(progress: AgentProgress[]): boolean {
-  return progress.some((event) => event.type === 'ToolStart' || event.type === 'ToolEnd')
-}
-
-export function mergeActivitySnapshots(
-  current: Record<string, AgentProgress[]>,
-  interactions: InteractionMemory[],
-): Record<string, AgentProgress[]> {
-  const merged = { ...current }
-  for (const interaction of interactions) {
-    const key = String(interaction.id)
-    if (interaction.agentActivity?.length && !merged[key]) {
-      merged[key] = interaction.agentActivity
-    }
-  }
-  return merged
-}
-
-export function parseAgentActivity(value: unknown): AgentProgress[] | undefined {
-  if (!Array.isArray(value)) return undefined
-  return value as AgentProgress[]
-}
+// Re-export everything from the shared module — do NOT add logic here.
+// Edit src/renderer/shared/agentProgress.ts instead.
+export type { AgentProgress, InteractionMemory } from '../shared/agentProgress'
+export {
+  thoughtsFrom,
+  trimAgentProgress,
+  hasAgentToolActivity,
+  mergeActivitySnapshots,
+  parseAgentActivity,
+  parseFileChangesFromProgress,
+} from '../shared/agentProgress'

package/src/renderer/src-web/calculator.ts

@@ -1,47 +1,4 @@
-export function evaluateArithmetic(source: string): number {
-  const tokens = source.replace(/\s+/g, '')
-  let index = 0
+// Re-export from the shared module — do NOT add logic here.
+// Edit src/renderer/shared/calculator.ts instead.
+export { evaluateArithmetic } from '../shared/calculator'
 
-  function parseExpression(): number {
-    let value = parseTerm()
-    while (tokens[index] === '+' || tokens[index] === '-') {
-      const operator = tokens[index++]
-      const right = parseTerm()
-      value = operator === '+' ? value + right : value - right
-    }
-    return value
-  }
-
-  function parseTerm(): number {
-    let value = parseFactor()
-    while (tokens[index] === '*' || tokens[index] === '/') {
-      const operator = tokens[index++]
-      const right = parseFactor()
-      value = operator === '*' ? value * right : value / right
-    }
-    return value
-  }
-
-  function parseFactor(): number {
-    if (tokens[index] === '+' || tokens[index] === '-') {
-      return tokens[index++] === '-' ? -parseFactor() : parseFactor()
-    }
-    if (tokens[index] === '(') {
-      index += 1
-      const value = parseExpression()
-      if (tokens[index++] !== ')') throw new Error('missing closing parenthesis')
-      return value
-    }
-    const match = tokens.slice(index).match(/^(?:\d+(?:\.\d*)?|\.\d+)/)
-    if (!match) throw new Error('expected a number')
-    index += match[0].length
-    return Number(match[0])
-  }
-
-  if (!tokens) throw new Error('expression is empty')
-  const result = parseExpression()
-  if (index !== tokens.length || !Number.isFinite(result)) {
-    throw new Error('invalid arithmetic expression')
-  }
-  return result
-}