@miphamai/cli 0.2.3

package/src/tools/file/read.ts

@@ -0,0 +1,38 @@
+import { readFileSync, existsSync, statSync } from 'node:fs'
+import type { ToolDefinition } from '../../shared/index.ts'
+import { resolveSafe } from '../../security/path'
+
+export const readTool: ToolDefinition = {
+  name: 'Read',
+  description: 'Read a file from the local filesystem. Supports offset and limit for large files.',
+  category: 'file',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: 'Absolute path to the file to read' },
+      offset: { type: 'integer', description: 'Line number to start reading from' },
+      limit: { type: 'integer', description: 'Number of lines to read' },
+    },
+    required: ['file_path'],
+  },
+  async execute(params, ctx) {
+    const filePath = resolveSafe(ctx.cwd, params.file_path as string)
+    if (!existsSync(filePath)) {
+      return { success: false, content: '', error: `File not found: ${filePath}` }
+    }
+    const stat = statSync(filePath)
+    if (stat.isDirectory()) {
+      return { success: false, content: '', error: `Path is a directory: ${filePath}` }
+    }
+    const offset = (params.offset as number) || 0
+    const limit = (params.limit as number) || 2000
+    const content = readFileSync(filePath, 'utf-8')
+    const lines = content.split('\n')
+    const slice = lines.slice(offset, offset + limit)
+    const result = slice
+      .map((l, i) => `${String(offset + i + 1).padStart(6, ' ')}\t${l}`)
+      .join('\n')
+    return { success: true, content: result }
+  },
+}

package/src/tools/file/write.ts

@@ -0,0 +1,27 @@
+import { writeFileSync, mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+import type { ToolDefinition } from '../../shared/index.ts'
+import { resolveSafe } from '../../security/path'
+
+export const writeTool: ToolDefinition = {
+  name: 'Write',
+  description: 'Write a file to the local filesystem. Creates parent directories if needed.',
+  category: 'file',
+  permission: 'ask',
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: 'Absolute path to write to' },
+      content: { type: 'string', description: 'Content to write' },
+    },
+    required: ['file_path', 'content'],
+  },
+  async execute(params, ctx) {
+    const filePath = resolveSafe(ctx.cwd, params.file_path as string)
+    const content = params.content as string
+    mkdirSync(dirname(filePath), { recursive: true })
+    writeFileSync(filePath, content, 'utf-8')
+    const lines = content.split('\n').length
+    return { success: true, content: `Wrote ${lines} lines to ${filePath}` }
+  },
+}

package/src/tools/index.ts

@@ -0,0 +1,126 @@
+import type { ToolDefinition, ToolResult } from '../shared/index.ts'
+import { readTool } from './file/read'
+import { writeTool } from './file/write'
+import { editTool } from './file/edit'
+import { globTool } from './file/glob'
+import { grepTool } from './file/grep'
+import { bashTool } from './exec/bash'
+import { gitTool } from './exec/git'
+import { taskTool } from './exec/task'
+import { agentTool } from './agent/agent'
+import { skillTool } from './agent/skill'
+import { planTool } from './agent/plan'
+import { memoryTool } from './agent/memory'
+import { webFetchTool } from './network/web-fetch'
+import { webSearchTool } from './network/web-search'
+import { configTool } from './system/config'
+import { mcpTool } from './system/mcp'
+
+/**
+ * Validate tool parameters against the tool's JSON Schema definition.
+ * Returns an array of error messages (empty = valid).
+ */
+function validateParams(
+  schema: Record<string, unknown>,
+  params: Record<string, unknown>,
+): string[] {
+  const errors: string[] = []
+
+  // Check required fields
+  const required = schema.required as string[] | undefined
+  if (required) {
+    for (const field of required) {
+      if (params[field] === undefined || params[field] === null) {
+        errors.push(`Missing required parameter: "${field}"`)
+      }
+    }
+  }
+
+  // Check types for provided fields
+  const properties = schema.properties as
+    | Record<string, { type: string; enum?: string[] }>
+    | undefined
+  if (properties) {
+    for (const [key, def] of Object.entries(properties)) {
+      const value = params[key]
+      if (value === undefined || value === null) continue // already caught by required check
+
+      switch (def.type) {
+        case 'string':
+          if (typeof value !== 'string') errors.push(`"${key}" must be a string`)
+          else if (def.enum && !def.enum.includes(value)) {
+            errors.push(`"${key}" must be one of: ${def.enum.join(', ')}`)
+          }
+          break
+        case 'integer':
+        case 'number':
+          if (typeof value !== 'number') errors.push(`"${key}" must be a number`)
+          break
+        case 'boolean':
+          if (typeof value !== 'boolean') errors.push(`"${key}" must be a boolean`)
+          break
+        case 'object':
+          if (typeof value !== 'object' || Array.isArray(value)) {
+            errors.push(`"${key}" must be an object`)
+          }
+          break
+        case 'array':
+          if (!Array.isArray(value)) errors.push(`"${key}" must be an array`)
+          break
+      }
+    }
+  }
+
+  return errors
+}
+
+/**
+ * Wrap a tool's execute with parameter validation.
+ */
+function withValidation(tool: ToolDefinition): ToolDefinition {
+  const schema = tool.parameters as Record<string, unknown>
+  if (!schema || !schema.properties) return tool // no schema to validate against
+
+  return {
+    ...tool,
+    async execute(params, ctx): Promise<ToolResult> {
+      const errors = validateParams(schema, params)
+      if (errors.length > 0) {
+        return { success: false, content: '', error: `Invalid parameters: ${errors.join('; ')}` }
+      }
+      return tool.execute(params, ctx)
+    },
+  }
+}
+
+export function createToolRegistry(): Map<string, ToolDefinition> {
+  const tools: ToolDefinition[] = [
+    // File tools
+    withValidation(readTool),
+    withValidation(writeTool),
+    withValidation(editTool),
+    withValidation(globTool),
+    withValidation(grepTool),
+    // Exec tools
+    withValidation(bashTool),
+    withValidation(gitTool),
+    withValidation(taskTool),
+    // Agent tools
+    withValidation(agentTool),
+    withValidation(skillTool),
+    withValidation(planTool),
+    withValidation(memoryTool),
+    // Network tools
+    withValidation(webFetchTool),
+    withValidation(webSearchTool),
+    // System tools
+    withValidation(configTool),
+    withValidation(mcpTool),
+  ]
+
+  const map = new Map<string, ToolDefinition>()
+  for (const tool of tools) {
+    map.set(tool.name, tool)
+  }
+  return map
+}

package/src/tools/network/web-fetch.ts

@@ -0,0 +1,61 @@
+import type { ToolDefinition } from '../../shared/index.ts'
+import { validateUrl } from '../../security/url'
+
+export const webFetchTool: ToolDefinition = {
+  name: 'WebFetch',
+  description: 'Fetch content from a URL and process into markdown.',
+  category: 'network',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      url: { type: 'string', format: 'uri', description: 'URL to fetch' },
+      prompt: { type: 'string', description: 'Prompt to run on fetched content' },
+    },
+    required: ['url'],
+  },
+  async execute(params, _ctx) {
+    const url = params.url as string
+
+    // SSRF protection: validate URL before fetching
+    const validationError = validateUrl(url)
+    if (validationError) {
+      return { success: false, content: '', error: validationError }
+    }
+
+    try {
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), 30_000) // 30s timeout
+
+      const response = await fetch(url, {
+        headers: { 'User-Agent': 'Mipham-Code/0.1.0' },
+        redirect: 'follow',
+        signal: controller.signal,
+      })
+
+      clearTimeout(timer)
+
+      if (!response.ok) {
+        return {
+          success: false,
+          content: '',
+          error: `HTTP ${response.status}: ${response.statusText}`,
+        }
+      }
+      const html = await response.text()
+      // Simple HTML-to-text extraction
+      const text = html
+        .replace(/<[^>]*>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 50_000)
+      return { success: true, content: text }
+    } catch (err) {
+      const message =
+        err instanceof Error && err.name === 'AbortError'
+          ? 'Request timed out (30s)'
+          : `Fetch failed: ${String(err)}`
+      return { success: false, content: '', error: message }
+    }
+  },
+}

package/src/tools/network/web-search.ts

@@ -0,0 +1,32 @@
+import type { ToolDefinition } from '../../shared/index.ts'
+
+export const webSearchTool: ToolDefinition = {
+  name: 'WebSearch',
+  description: 'Search the web. Returns result titles and URLs.',
+  category: 'network',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', minLength: 2, description: 'Search query' },
+      allowed_domains: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Only include results from these domains',
+      },
+      blocked_domains: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Never include results from these domains',
+      },
+    },
+    required: ['query'],
+  },
+  async execute(params, _ctx) {
+    const query = params.query as string
+    return {
+      success: true,
+      content: `WebSearch query: "${query}". Results would appear here when search API is configured.`,
+    }
+  },
+}

package/src/tools/system/config.ts

@@ -0,0 +1,68 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { parse as parseYaml, stringify } from 'yaml'
+import type { ToolDefinition } from '../../shared/index.ts'
+
+const MIPHAM_DIR = join(process.env.HOME || '~', '.mipham')
+const USER_CONFIG = join(MIPHAM_DIR, 'config.yml')
+
+export const configTool: ToolDefinition = {
+  name: 'Config',
+  description: 'Read or update Mipham Code configuration.',
+  category: 'system',
+  permission: 'ask',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['get', 'set', 'list'],
+        description: 'Action to perform',
+      },
+      key: { type: 'string', description: 'Config key (dot notation)' },
+      value: { type: 'string', description: 'Value to set' },
+    },
+    required: ['action'],
+  },
+  async execute(params, _ctx) {
+    mkdirSync(MIPHAM_DIR, { recursive: true })
+    const action = params.action as string
+
+    let config: Record<string, unknown> = {}
+    if (existsSync(USER_CONFIG)) {
+      config = parseYaml(readFileSync(USER_CONFIG, 'utf-8')) as Record<string, unknown>
+    }
+
+    if (action === 'list') {
+      return { success: true, content: stringify(config) || '(empty config)' }
+    }
+
+    const key = params.key as string
+    if (!key) return { success: false, content: '', error: 'key is required for get/set' }
+
+    if (action === 'get') {
+      const value = key.split('.').reduce((obj: unknown, k) => {
+        if (obj && typeof obj === 'object') {
+          return (obj as Record<string, unknown>)[k]
+        }
+        return undefined
+      }, config)
+      return { success: true, content: JSON.stringify(value) }
+    }
+
+    if (action === 'set') {
+      const keys = key.split('.')
+      let obj: Record<string, unknown> = config
+      for (let i = 0; i < keys.length - 1; i++) {
+        const k = keys[i]!
+        if (!obj[k]) obj[k] = {}
+        obj = obj[k] as Record<string, unknown>
+      }
+      obj[keys[keys.length - 1]!] = params.value
+      writeFileSync(USER_CONFIG, stringify(config), 'utf-8')
+      return { success: true, content: `Set ${key} = ${params.value}` }
+    }
+
+    return { success: false, content: '', error: `Unknown action: ${action}` }
+  },
+}

package/src/tools/system/mcp.ts

@@ -0,0 +1,75 @@
+import type { ToolDefinition } from '../../shared/index.ts'
+import { McpClient } from '../../mcp/client'
+
+export const mcpTool: ToolDefinition = {
+  name: 'MCP',
+  description:
+    'Interact with MCP (Model Context Protocol) servers. Call tools on connected MCP servers via JSON-RPC 2.0 over stdio.',
+  category: 'system',
+  permission: 'ask',
+  parameters: {
+    type: 'object',
+    properties: {
+      server: {
+        type: 'string',
+        description: 'MCP server name as configured in .mipham/config.yml',
+      },
+      tool: { type: 'string', description: 'Tool name on the MCP server' },
+      params: { type: 'object', description: 'Parameters to pass to the tool' },
+    },
+    required: ['server', 'tool'],
+  },
+  async execute(params, _ctx) {
+    const server = params.server as string
+    const toolName = params.tool as string
+    const toolParams = (params.params as Record<string, unknown>) || {}
+
+    const client = McpClient.getInstance()
+    const connection = client.getConnection(server)
+
+    if (!connection) {
+      return {
+        success: false,
+        content: '',
+        error: `MCP server "${server}" is not configured.\n\nAdd it to .mipham/config.yml under skills.mcpServers, or check available servers with /mcp.`,
+      }
+    }
+
+    if (connection.status !== 'connected') {
+      return {
+        success: false,
+        content: '',
+        error: `MCP server "${server}" is not connected (status: ${connection.status}).\n${connection.error ? 'Error: ' + connection.error : 'Use /mcp to check status.'}`,
+      }
+    }
+
+    // Check if the requested tool exists on this server
+    const toolExists = connection.tools.some((t) => t.name === toolName)
+    if (!toolExists) {
+      const availableTools = connection.tools.map((t) => `  • ${t.name}`).join('\n')
+      return {
+        success: false,
+        content: '',
+        error: `Tool "${toolName}" not found on MCP server "${server}".\n\nAvailable tools:\n${availableTools || '  (none discovered)'}`,
+      }
+    }
+
+    // Execute the tool via the MCP client
+    const result = await client.callTool(server, toolName, toolParams)
+
+    // Format the result content
+    const text = result.content
+      .map((c) => {
+        if (c.type === 'text' && c.text) return c.text
+        if (c.type === 'image') return `[Image: ${c.mimeType || 'unknown'}]`
+        return JSON.stringify(c)
+      })
+      .join('\n')
+
+    return {
+      success: !result.isError,
+      content: text || '(empty result)',
+      error: result.isError ? text : undefined,
+    }
+  },
+}