@miphamai/cli 0.2.3

package/src/core/hooks.ts

@@ -0,0 +1,116 @@
+import type {
+  HookDefinition,
+  HookEvent,
+  HookContext,
+  HookResult,
+  ToolResult,
+} from '../shared/index.ts'
+
+export class HookEngine {
+  private hooks: HookDefinition[] = []
+
+  register(hook: HookDefinition): void {
+    this.hooks.push(hook)
+  }
+
+  unregister(event: HookEvent, toolName?: string): void {
+    this.hooks = this.hooks.filter(
+      (h) => !(h.event === event && (!toolName || h.toolName === toolName)),
+    )
+  }
+
+  async executePreToolUse(
+    toolName: string,
+    toolInput: Record<string, unknown>,
+    sessionId: string,
+  ): Promise<HookResult> {
+    const ctx: HookContext = {
+      event: 'PreToolUse',
+      toolName,
+      toolInput,
+      sessionId,
+    }
+
+    return this.runHooks('PreToolUse', toolName, ctx)
+  }
+
+  async executePostToolUse(
+    toolName: string,
+    toolInput: Record<string, unknown>,
+    toolResult: ToolResult,
+    sessionId: string,
+  ): Promise<HookResult> {
+    const ctx: HookContext = {
+      event: 'PostToolUse',
+      toolName,
+      toolInput,
+      toolResult,
+      sessionId,
+    }
+
+    return this.runHooks('PostToolUse', toolName, ctx)
+  }
+
+  async executeSessionStart(sessionId: string): Promise<HookResult> {
+    const ctx: HookContext = {
+      event: 'SessionStart',
+      sessionId,
+    }
+
+    return this.runHooks('SessionStart', undefined, ctx)
+  }
+
+  async executeSessionEnd(sessionId: string): Promise<HookResult> {
+    const ctx: HookContext = {
+      event: 'SessionEnd',
+      sessionId,
+    }
+
+    return this.runHooks('SessionEnd', undefined, ctx)
+  }
+
+  async executeNotification(message: string, sessionId: string): Promise<HookResult> {
+    const ctx: HookContext = {
+      event: 'Notification',
+      sessionId,
+      toolInput: { message },
+    }
+
+    return this.runHooks('Notification', undefined, ctx)
+  }
+
+  private async runHooks(
+    event: HookEvent,
+    toolName: string | undefined,
+    ctx: HookContext,
+  ): Promise<HookResult> {
+    const matching = this.hooks.filter(
+      (h) => h.event === event && (!toolName || !h.toolName || h.toolName === toolName),
+    )
+
+    const result: HookResult = { allowed: true }
+
+    for (const hook of matching) {
+      try {
+        const hookResult = await hook.handler(ctx)
+        if (!hookResult.allowed) {
+          return hookResult // Block on first deny
+        }
+        if (hookResult.modifiedInput) {
+          result.modifiedInput = {
+            ...(result.modifiedInput || {}),
+            ...hookResult.modifiedInput,
+          }
+        }
+      } catch {
+        // Hook failures do not block execution
+      }
+    }
+
+    return result
+  }
+
+  listHooks(): HookDefinition[] {
+    return [...this.hooks]
+  }
+}

package/src/core/instructions.ts

@@ -0,0 +1,126 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import { parse as parseYaml } from 'yaml'
+import type { InstructionFile } from '../shared/index.ts'
+
+interface FrontmatterResult {
+  data: Record<string, unknown>
+  content: string
+}
+
+function parseFrontmatter(raw: string): FrontmatterResult {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  if (!match) {
+    return { data: {}, content: raw }
+  }
+  return {
+    data: parseYaml(match[1] || '') as Record<string, unknown>,
+    content: match[2] || '',
+  }
+}
+
+export class InstructionsLoader {
+  private instructions: InstructionFile[] = []
+
+  loadAll(cwd: string): void {
+    this.instructions = []
+
+    // Tier 1: Ancestor-level CLAUDE.md (for Claude Code compatibility)
+    // ../../ = Rismed_Ronxin_Capital
+    this.tryLoad(join(cwd, '..', '..', 'CLAUDE.md'), 'group')
+    // ../ = One_Mipham_Corporation
+    this.tryLoad(join(cwd, '..', 'CLAUDE.md'), 'company')
+
+    // Tier 1b: Group-level MIPHAM.md — One_Mipham_Corporation is the root
+    this.tryLoad(join(cwd, '..', 'MIPHAM.md'), 'group')
+
+    // Tier 2: Project-level (CLAUDE.md + MIPHAM.md at cwd)
+    this.tryLoad(join(cwd, 'MIPHAM.md'), 'project')
+    this.tryLoad(join(cwd, 'CLAUDE.md'), 'project')
+
+    // Tier 2b: Directory-level MIPHAM.md (recursive, up to 3 levels)
+    this.tryLoadRecursive(cwd, 'directory')
+
+    // Tier 3: User-level ~/.mipham/USER.md
+    const home = process.env.HOME || '~'
+    this.tryLoad(join(home, '.mipham', 'USER.md'), 'user')
+  }
+
+  buildSystemPrompt(): string {
+    const parts: string[] = []
+
+    for (const inst of this.instructions) {
+      const levelLabel: Record<string, string> = {
+        group: 'Group Policy',
+        company: 'Company Policy',
+        project: 'Project Rules',
+        directory: 'Directory Rules',
+        user: 'User Preferences',
+      }
+      parts.push(`<!-- ${levelLabel[inst.level] || inst.level} (${inst.path}) -->\n${inst.content}`)
+    }
+
+    return parts.join('\n\n---\n\n')
+  }
+
+  list(): InstructionFile[] {
+    return [...this.instructions]
+  }
+
+  private tryLoad(path: string, level: InstructionFile['level']): void {
+    if (!existsSync(path)) return
+
+    try {
+      const raw = readFileSync(path, 'utf-8')
+      const { data, content } = parseFrontmatter(raw)
+      this.instructions.push({
+        path,
+        level,
+        privacy: (data.privacy as InstructionFile['privacy']) || 'project',
+        language: (data.language as string) || 'en-US',
+        content,
+        frontmatter: data,
+      })
+    } catch {
+      // Silently skip unreadable files
+    }
+  }
+
+  private tryLoadRecursive(dir: string, level: InstructionFile['level']): void {
+    const maxDepth = 3
+
+    const walk = (current: string, depth: number) => {
+      if (depth > maxDepth) return
+
+      // Check for MIPHAM.md in this directory
+      const miphamPath = join(current, 'MIPHAM.md')
+      if (existsSync(miphamPath) && current !== dir) {
+        this.tryLoad(miphamPath, level)
+      }
+      // Also check for CLAUDE.md
+      const claudeMdPath = join(current, 'CLAUDE.md')
+      if (existsSync(claudeMdPath) && current !== dir) {
+        this.tryLoad(claudeMdPath, level)
+      }
+
+      try {
+        const items = readdirSync(current, { withFileTypes: true })
+        for (const item of items) {
+          if (
+            item.isDirectory() &&
+            !item.name.startsWith('.') &&
+            item.name !== 'node_modules' &&
+            item.name !== 'dist' &&
+            item.name !== '.next'
+          ) {
+            walk(join(current, item.name), depth + 1)
+          }
+        }
+      } catch {
+        // skip unreadable directories
+      }
+    }
+
+    walk(dir, 0)
+  }
+}

package/src/core/permission.ts

@@ -0,0 +1,54 @@
+import type { ToolDefinition, ToolPermission, PermissionLevel } from '../shared/index.ts'
+
+export class PermissionSystem {
+  private rules = new Map<string, PermissionLevel>()
+
+  constructor(private defaultLevel: ToolPermission = 'auto') {}
+
+  setDefaultLevel(level: PermissionLevel): void {
+    this.defaultLevel = level
+  }
+
+  getDefaultLevel(): PermissionLevel {
+    return this.defaultLevel
+  }
+
+  setRule(toolName: string, level: PermissionLevel): void {
+    this.rules.set(toolName, level)
+  }
+
+  removeRule(toolName: string): void {
+    this.rules.delete(toolName)
+  }
+
+  check(tool: ToolDefinition, _input: Record<string, unknown>): PermissionLevel {
+    const ruleLevel = this.rules.get(tool.name)
+    if (ruleLevel) return ruleLevel
+    return tool.permission
+  }
+
+  needsApproval(tool: ToolDefinition, input: Record<string, unknown>): boolean {
+    return this.check(tool, input) === 'ask'
+  }
+
+  isBypassed(tool: ToolDefinition, input: Record<string, unknown>): boolean {
+    return this.check(tool, input) === 'bypass'
+  }
+
+  listRules(): Map<string, PermissionLevel> {
+    return new Map(this.rules)
+  }
+
+  getByCategory(
+    tools: Map<string, ToolDefinition>,
+    category: string,
+  ): Array<{ name: string; level: PermissionLevel }> {
+    const result: Array<{ name: string; level: PermissionLevel }> = []
+    for (const [name, tool] of tools) {
+      if (tool.category === category) {
+        result.push({ name, level: this.check(tool, {}) })
+      }
+    }
+    return result
+  }
+}

package/src/core/session-store.ts

@@ -0,0 +1,136 @@
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import type { Message } from '../shared/types'
+
+export interface SessionMetadata {
+  name: string
+  createdAt: string
+  updatedAt: string
+  provider: string
+  model: string
+  messageCount: number
+}
+
+export interface StoredSession {
+  metadata: SessionMetadata
+  messages: Message[]
+}
+
+const HOME = process.env.HOME || '~'
+const SESSIONS_DIR = join(HOME, '.mipham', 'sessions')
+
+function ensureDir(): void {
+  mkdirSync(SESSIONS_DIR, { recursive: true })
+}
+
+function filePath(name: string): string {
+  // Sanitize name for filesystem
+  const safe = name.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 100)
+  return join(SESSIONS_DIR, `${safe}.jsonl`)
+}
+
+export class SessionStore {
+  /**
+   * Save a session as JSONL (one JSON object per line).
+   */
+  static save(
+    name: string,
+    messages: Message[],
+    metadata?: { provider?: string; model?: string },
+  ): void {
+    ensureDir()
+    const path = filePath(name)
+
+    const session: StoredSession = {
+      metadata: {
+        name,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        provider: metadata?.provider || 'unknown',
+        model: metadata?.model || 'unknown',
+        messageCount: messages.length,
+      },
+      messages,
+    }
+
+    writeFileSync(path, JSON.stringify(session) + '\n', 'utf-8')
+  }
+
+  /**
+   * Load a saved session. Returns null if not found or unparseable.
+   */
+  static load(name: string): StoredSession | null {
+    const path = filePath(name)
+    if (!existsSync(path)) return null
+
+    try {
+      const raw = readFileSync(path, 'utf-8')
+      const session = JSON.parse(raw) as StoredSession
+      // Validate structure
+      if (!session.metadata || !Array.isArray(session.messages)) {
+        return null
+      }
+      return session
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * List all saved sessions, most recent first.
+   */
+  static list(): SessionMetadata[] {
+    ensureDir()
+    try {
+      const files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith('.jsonl'))
+
+      const sessions: SessionMetadata[] = []
+      for (const file of files) {
+        try {
+          const raw = readFileSync(join(SESSIONS_DIR, file), 'utf-8')
+          const session = JSON.parse(raw) as StoredSession
+          if (session.metadata) {
+            sessions.push(session.metadata)
+          }
+        } catch {
+          // Skip corrupt files
+        }
+      }
+
+      sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+      return sessions
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Delete a saved session.
+   */
+  static delete(name: string): boolean {
+    const path = filePath(name)
+    if (!existsSync(path)) return false
+    try {
+      unlinkSync(path)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Auto-save with timestamp-based name.
+   */
+  static autoSave(messages: Message[], metadata?: { provider?: string; model?: string }): string {
+    const name = `session-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)}`
+    SessionStore.save(name, messages, metadata)
+    return name
+  }
+}

package/src/index.tsx

@@ -0,0 +1,93 @@
+import { render } from 'ink'
+import { App } from './ui/app'
+import { loadConfig } from './config/loader'
+import { bootstrapProviders } from './providers/bootstrap'
+import { InstructionsLoader } from './core/instructions'
+import { ContextManager } from './core/context'
+import { QueryEngine } from './core/engine'
+import { SessionStore } from './core/session-store'
+import { SkillsLoader } from './skills/loader'
+import { createToolRegistry } from './tools'
+
+interface RunOptions {
+  model?: string
+  provider?: string
+  lang?: string
+  permission?: string
+  resume?: string
+}
+
+export async function runApp(options: RunOptions): Promise<void> {
+  // Set terminal window title
+  process.stdout.write('\x1b]0;Mipham Code\x07')
+
+  // Load configuration
+  const config = loadConfig()
+
+  // Bootstrap providers
+  const defaultProvider = options.provider || config.defaultProvider
+  const defaultModel = options.model || config.defaultModel
+  const registry = bootstrapProviders(config.providers, defaultProvider, defaultModel)
+
+  // Load instructions
+  const instructions = new InstructionsLoader()
+  instructions.loadAll(process.cwd())
+
+  // Load skills
+  const skillsLoader = new SkillsLoader()
+  skillsLoader.loadBuiltin(process.cwd())
+  if (config.skills?.paths) {
+    skillsLoader.loadExternal(config.skills.paths)
+  }
+
+  // Initialize context — restore saved session if available
+  const context = new ContextManager({ maxTokens: 200_000, compactionThreshold: 0.9 })
+
+  if (options.resume) {
+    const saved = SessionStore.load(options.resume)
+    if (saved) {
+      for (const msg of saved.messages) {
+        context.addMessage(msg)
+      }
+      context.setSystemPrompt(instructions.buildSystemPrompt())
+    }
+  }
+
+  if (context.getMessageCount() === 0) {
+    context.setSystemPrompt(instructions.buildSystemPrompt())
+  }
+
+  // Create tool registry with all 16 tools
+  const tools = createToolRegistry()
+
+  // Create query engine
+  const engine = new QueryEngine(registry, context, tools)
+
+  // Auto-save session on exit
+  let autoSaveName: string | undefined
+  const saveAndExit = () => {
+    if (context.getMessageCount() > 0) {
+      autoSaveName = SessionStore.autoSave(context.getMessages(), {
+        provider: defaultProvider,
+        model: defaultModel,
+      })
+    }
+    process.exit(0)
+  }
+
+  process.on('SIGINT', saveAndExit)
+  process.on('SIGTERM', saveAndExit)
+
+  const { waitUntilExit } = render(
+    <App
+      engine={engine}
+      config={config}
+      initialProvider={defaultProvider}
+      initialModel={defaultModel}
+      lang={options.lang}
+      skillsLoader={skillsLoader}
+    />,
+  )
+  await waitUntilExit()
+  saveAndExit()
+}

package/src/mcp/client.ts

@@ -0,0 +1,170 @@
+import type { McpServerConfig } from '../shared/types'
+import type {
+  ConnectionStatus,
+  ConnectionInfo,
+  ToolDefinition,
+  ToolCallResult,
+  InitializeResult,
+} from './types'
+import { StdioTransport } from './transport'
+import { McpProtocol } from './protocol'
+
+interface ActiveConnection {
+  config: McpServerConfig
+  transport: StdioTransport
+  protocol: McpProtocol
+  status: ConnectionStatus
+  tools: ToolDefinition[]
+  serverInfo?: { name: string; version: string }
+  error?: string
+}
+
+/**
+ * Singleton MCP client — manages connections to multiple MCP servers.
+ *
+ * Lifecycle:
+ *   1. connect(config) — spawn process, initialize, discover tools
+ *   2. callTool(server, tool, params) — execute tool on connected server
+ *   3. disconnect(name) or closeAll() — kill subprocess, clean up
+ *
+ * Backward-compatible with the previous stub McpClient API.
+ */
+export class McpClient {
+  private static instance: McpClient | null = null
+  private connections = new Map<string, ActiveConnection>()
+
+  /** Get or create the singleton instance. */
+  static getInstance(): McpClient {
+    if (!McpClient.instance) {
+      McpClient.instance = new McpClient()
+    }
+    return McpClient.instance
+  }
+
+  /** Reset the singleton (useful for testing). */
+  static resetInstance(): void {
+    McpClient.instance = null
+  }
+
+  async connect(config: McpServerConfig): Promise<void> {
+    // Skip if already connected
+    const existing = this.connections.get(config.name)
+    if (existing?.status === 'connected') return
+
+    const transport = new StdioTransport()
+    const protocol = new McpProtocol(transport)
+
+    const connection: ActiveConnection = {
+      config,
+      transport,
+      protocol,
+      status: 'connecting',
+      tools: [],
+    }
+
+    this.connections.set(config.name, connection)
+
+    try {
+      const initResult: InitializeResult = await protocol.initialize(
+        config.command,
+        config.args,
+        config.env,
+      )
+
+      connection.status = 'connected'
+      connection.serverInfo = initResult.serverInfo
+
+      // Discover tools
+      if (initResult.capabilities.tools) {
+        connection.tools = await protocol.listTools()
+      }
+    } catch (err) {
+      connection.status = 'error'
+      connection.error = String(err)
+      throw err
+    }
+  }
+
+  disconnect(name: string): void {
+    const conn = this.connections.get(name)
+    if (!conn) return
+
+    try {
+      conn.transport.close()
+    } catch {
+      /* best effort */
+    }
+    this.connections.delete(name)
+  }
+
+  async closeAll(): Promise<void> {
+    const names = Array.from(this.connections.keys())
+    for (const name of names) {
+      try {
+        await this.connections.get(name)?.transport.close()
+      } catch {
+        /* best effort */
+      }
+      this.connections.delete(name)
+    }
+    McpClient.instance = null
+  }
+
+  getConnection(name: string): ConnectionInfo | undefined {
+    const conn = this.connections.get(name)
+    if (!conn) return undefined
+
+    return {
+      config: {
+        name: conn.config.name,
+        command: conn.config.command,
+        args: conn.config.args,
+      },
+      status: conn.status,
+      tools: conn.tools,
+      error: conn.error,
+      serverInfo: conn.serverInfo,
+    }
+  }
+
+  listConnections(): ConnectionInfo[] {
+    return Array.from(this.connections.values()).map((conn) => ({
+      config: {
+        name: conn.config.name,
+        command: conn.config.command,
+        args: conn.config.args,
+      },
+      status: conn.status,
+      tools: conn.tools,
+      error: conn.error,
+      serverInfo: conn.serverInfo,
+    }))
+  }
+
+  getTools(name: string): ToolDefinition[] {
+    return this.connections.get(name)?.tools || []
+  }
+
+  async callTool(
+    serverName: string,
+    toolName: string,
+    params?: Record<string, unknown>,
+  ): Promise<ToolCallResult> {
+    const conn = this.connections.get(serverName)
+    if (!conn || conn.status !== 'connected') {
+      return {
+        content: [{ type: 'text', text: `Error: MCP server "${serverName}" not connected` }],
+        isError: true,
+      }
+    }
+
+    try {
+      return await conn.protocol.callTool(toolName, params)
+    } catch (err) {
+      return {
+        content: [{ type: 'text', text: `MCP tool error: ${String(err)}` }],
+        isError: true,
+      }
+    }
+  }
+}