@miphamai/cli 0.10.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent/agent-context.ts

@@ -1,4 +1,7 @@
 // apps/cli/src/agent/agent-context.ts
+import { readdirSync, readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
 import { ContextManager } from '../core/context'
 import type { ToolDefinition } from '../shared/index.ts'
 import type { AgentDefinition } from './types'
@@ -8,6 +11,50 @@ export interface AgentContextResult {
   allowedTools: ToolDefinition[]
 }
 
+/**
+ * Load agent memory files from the appropriate scope directory.
+ * Returns combined content for injection into the system prompt.
+ */
+function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local'): string {
+  let memoryDir: string
+  const home = homedir()
+
+  switch (scope) {
+    case 'user':
+      memoryDir = join(home, '.mipham', 'agent-memory', agentName)
+      break
+    case 'project':
+      memoryDir = join(process.cwd(), '.mipham', 'agent-memory', agentName)
+      break
+    case 'local':
+      memoryDir = join(process.cwd(), '.mipham', 'agent-memory-local', agentName)
+      break
+  }
+
+  if (!existsSync(memoryDir)) return ''
+
+  try {
+    const files = readdirSync(memoryDir).filter((f) => f.endsWith('.md'))
+    if (files.length === 0) return ''
+
+    const contents: string[] = []
+    for (const file of files.slice(0, 10)) {
+      // max 10 files
+      try {
+        const content = readFileSync(join(memoryDir, file), 'utf-8').trim()
+        if (content) contents.push(content)
+      } catch {
+        // skip unreadable
+      }
+    }
+
+    if (contents.length === 0) return ''
+    return [`[Agent Memory — ${scope} scope]`, ...contents].join('\n\n')
+  } catch {
+    return ''
+  }
+}
+
 /**
  * Create an isolated context and tool set for a sub-agent.
  *
@@ -15,6 +62,9 @@ export interface AgentContextResult {
  * 1. If `tools` is set, only those tools are allowed.
  * 2. If `disallowedTools` is set, those are removed from the full set.
  * 3. If neither is set, all tools are available.
+ *
+ * Agent memory: if agentDef.memory is set, loads memory files from the
+ * appropriate scope and injects them into the system prompt.
  */
 export function createAgentContext(
   agentDef: AgentDefinition,
@@ -27,7 +77,16 @@ export function createAgentContext(
     compactionThreshold: 0.85,
   })
 
-  context.setSystemPrompt(agentDef.systemPrompt)
+  // Build system prompt with optional agent memory
+  let systemPrompt = agentDef.systemPrompt
+  if (agentDef.memory) {
+    const memory = loadAgentMemory(agentDef.name, agentDef.memory)
+    if (memory) {
+      systemPrompt = `${systemPrompt}\n\n---\n\n${memory}`
+    }
+  }
+
+  context.setSystemPrompt(systemPrompt)
 
   // Scope tools
   let allowedTools = Array.from(toolRegistry.values())

package/src/agent/agent-registry.ts

@@ -74,6 +74,7 @@ export class AgentRegistry {
                 .map((s) => s.trim())
             : undefined,
           background: (data.background as boolean) || false,
+          memory: data.memory as 'user' | 'project' | 'local' | undefined,
           source,
           filePath: fullPath,
         }

package/src/agent/types.ts

@@ -12,6 +12,7 @@ export interface AgentFrontmatter {
   maxTurns?: number
   skills?: string
   background?: boolean
+  memory?: 'user' | 'project' | 'local' // agent memory scope
 }
 
 export interface AgentDefinition {
@@ -27,6 +28,7 @@ export interface AgentDefinition {
   background: boolean
   source: 'builtin' | 'project' | 'user'
   filePath?: string
+  memory?: 'user' | 'project' | 'local' // agent memory scope
 }
 
 export interface SubAgentOptions {

package/src/artifacts/server.ts

@@ -5,6 +5,7 @@ import { ARTIFACT_ALLOWED_EXTENSIONS } from '../shared/constants'
 import { readManifest } from './manifest'
 import { ArtifactVersioning } from './versioning'
 import type { ArtifactEntry } from '../shared/types'
+import { getMetrics } from '../core/metrics'
 
 // ── SSE client tracking ──
 interface SseClient {
@@ -151,10 +152,48 @@ export class ArtifactServer {
       return
     }
 
+    // Metrics endpoint — Prometheus text format
+    if (urlPath === '/metrics') {
+      this.serveMetrics(res, 'prometheus')
+      return
+    }
+
+    // Metrics endpoint — JSON format
+    if (urlPath === '/metrics/json') {
+      this.serveMetrics(res, 'json')
+      return
+    }
+
     // Artifact file
     this.serveArtifact(urlPath, res)
   }
 
+  // ── Metrics ──
+
+  private serveMetrics(res: any, format: 'prometheus' | 'json'): void {
+    try {
+      const metrics = getMetrics()
+      if (format === 'json') {
+        const body = JSON.stringify(metrics.toJSON(), null, 2)
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        })
+        res.end(body)
+      } else {
+        const body = metrics.toPrometheusText()
+        res.writeHead(200, {
+          'Content-Type': 'text/plain; charset=utf-8',
+          'Access-Control-Allow-Origin': '*',
+        })
+        res.end(body)
+      }
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'text/plain' })
+      res.end(`Metrics error: ${err instanceof Error ? err.message : 'unknown'}`)
+    }
+  }
+
   // ── SSE ──
 
   private handleSse(res: any): void {

package/src/config/defaults.ts

@@ -1,4 +1,4 @@
-import type { MiphamConfig } from '../shared/index.ts'
+import type { MiphamConfig, InferenceHookConfig } from '../shared/index.ts'
 import { DEFAULT_PROVIDERS } from '../shared/index.ts'
 import { PACKAGE_VERSION } from '../shared/index.ts'
 
@@ -9,3 +9,12 @@ export const DEFAULT_CONFIG: MiphamConfig = {
   permission: 'auto',
   providers: DEFAULT_PROVIDERS,
 }
+
+export const DEFAULT_INFERENCE_HOOK_CONFIG: InferenceHookConfig = {
+  endpoint: '',
+  signing_secret: '',
+  timeout: 5000,
+  on_failure: 'fail-closed',
+  organization_id: '',
+  headers: {},
+}

package/src/config/loader.ts

@@ -10,8 +10,13 @@ import {
 import { join, dirname } from 'node:path'
 import { homedir } from 'node:os'
 import { parse as parseYaml } from 'yaml'
-import type { MiphamConfig, ProviderConfig, McpServerConfig } from '../shared/index.ts'
-import { DEFAULT_CONFIG } from './defaults'
+import type {
+  MiphamConfig,
+  ProviderConfig,
+  McpServerConfig,
+  InferenceHookConfig,
+} from '../shared/index.ts'
+import { DEFAULT_CONFIG, DEFAULT_INFERENCE_HOOK_CONFIG } from './defaults'
 
 const MIPHAM_HOME = join(homedir(), '.mipham')
 const BACKUP_PREFIX = 'config.backup-'
@@ -256,3 +261,40 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
 
   return config
 }
+
+/**
+ * Load inference hooks (DLP) configuration from the same config sources
+ * as the main config. Merges project-level over user-level.
+ *
+ * Returns default (disabled) config if no inference_hooks section is present.
+ */
+export function loadInferenceHookConfig(cwd: string = process.cwd()): InferenceHookConfig {
+  const configPath = join(cwd, '.mipham', 'config.yml')
+  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
+
+  let merged = { ...DEFAULT_INFERENCE_HOOK_CONFIG }
+
+  const paths = [userConfigPath, configPath] // project wins (loaded last)
+  for (const path of paths) {
+    try {
+      if (!existsSync(path)) continue
+      const raw = readFileSync(path, 'utf-8')
+      const parsed = parseYaml(raw) as Record<string, unknown>
+      const section = parsed.inference_hooks as Partial<InferenceHookConfig> | undefined
+      if (section) {
+        merged = {
+          endpoint: section.endpoint ?? merged.endpoint,
+          signing_secret: section.signing_secret ?? merged.signing_secret,
+          timeout: section.timeout ?? merged.timeout,
+          on_failure: section.on_failure ?? merged.on_failure,
+          organization_id: section.organization_id ?? merged.organization_id,
+          headers: { ...merged.headers, ...(section.headers || {}) },
+        }
+      }
+    } catch {
+      // Silently skip malformed configs — main loadConfig already warns
+    }
+  }
+
+  return merged
+}

package/src/core/engine.ts

@@ -1,4 +1,9 @@
-import type { StreamChunk, ToolDefinition, ToolResult } from '../shared/index.ts'
+import type {
+  StreamChunk,
+  ToolDefinition,
+  ToolResult,
+  InferenceHookConfig,
+} from '../shared/index.ts'
 import { ProviderRegistry } from '../providers/registry'
 import { ContextManager } from './context'
 import { PermissionSystem } from './permission'
@@ -10,6 +15,8 @@ import { getMemoryManager } from './memory/memory-loader'
 import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import type { SkillsLoader } from '../skills/loader'
 import { getBackgroundAgentRegistry } from '../agent/background-registry'
+import { RulesLoader } from './rules-loader'
+import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 
 export class QueryEngine {
   private hookEngine?: HookEngine
@@ -71,9 +78,47 @@ export class QueryEngine {
     this.skillsLoader = loader
   }
 
+  /** Rules loader for path-scoped rules injection. */
+  private rulesLoader?: RulesLoader
+  /** Files touched in the current turn (for rules matching). */
+  private touchedFiles: Set<string> = new Set()
+  /** Inference hook (DLP) configuration. */
+  private inferenceHookConfig?: InferenceHookConfig
+
+  /** Register the rules loader. */
+  setRulesLoader(loader: RulesLoader): void {
+    this.rulesLoader = loader
+    this.rulesLoader.load()
+  }
+
+  /** Register inference hook (DLP) configuration. */
+  setInferenceHookConfig(config: InferenceHookConfig): void {
+    this.inferenceHookConfig = config
+  }
+
   /** Pending task notifications from background agents (cleared after draining). */
   private pendingTaskNotifications: Array<StreamChunk> = []
 
+  /** Track files touched by tools for rules matching. */
+  private trackTouchedFile(toolName: string, params: Record<string, unknown>): void {
+    const fileTools = ['Read', 'Write', 'Edit', 'Glob', 'Grep']
+    if (!fileTools.includes(toolName)) return
+    const filePath = (params.file_path || params.path || params.file) as string | undefined
+    if (filePath && typeof filePath === 'string') {
+      this.touchedFiles.add(filePath)
+    }
+  }
+
+  /** Inject matching rules as context after tool execution. */
+  private injectRules(): void {
+    if (!this.rulesLoader || this.touchedFiles.size === 0) return
+    const files = Array.from(this.touchedFiles)
+    const block = this.rulesLoader.buildContextBlock(files)
+    if (!block) return
+    this.context.addMessage({ role: 'user', content: block })
+    this.touchedFiles.clear()
+  }
+
   /**
    * Drain pending background task notifications.
    * Call this after tool execution to surface completed/failed background agent results.
@@ -224,6 +269,27 @@ export class QueryEngine {
     const messages = this.context.getMessages()
     const toolDefs = this.getToolDefinitions()
 
+    // ── PreInference DLP checkpoint ──
+    if (isInferenceHookEnabled(this.inferenceHookConfig)) {
+      const provider = this.registry.getActive().config.id
+      const model = this.registry.getActiveModel()
+      const request = buildRequest(
+        messages,
+        'session-1',
+        provider,
+        model,
+        this.inferenceHookConfig!.organization_id,
+      )
+      const verdict = await sendInferenceCheck(this.inferenceHookConfig!, request)
+      if (!verdict.allowed) {
+        yield {
+          type: 'error',
+          error: verdict.reason || 'Request blocked by DLP policy.',
+        }
+        return
+      }
+    }
+
     let assistantContent = ''
     let reasoningContent = ''
     let thinkingContent = ''
@@ -351,6 +417,9 @@ export class QueryEngine {
       })
     }
 
+    // Inject path-scoped rules for touched files
+    this.injectRules()
+
     // Drain task notifications after tool execution
     for (const chunk of this.drainTaskNotifications()) {
       yield chunk
@@ -446,6 +515,27 @@ export class QueryEngine {
       const systemPrompt = this.context.getSystemPrompt()
       const messages = this.context.getMessages()
 
+      // ── PreInference DLP checkpoint (every tool-calling turn) ──
+      if (isInferenceHookEnabled(this.inferenceHookConfig)) {
+        const provider = this.registry.getActive().config.id
+        const model = this.registry.getActiveModel()
+        const request = buildRequest(
+          messages,
+          'session-1',
+          provider,
+          model,
+          this.inferenceHookConfig!.organization_id,
+        )
+        const verdict = await sendInferenceCheck(this.inferenceHookConfig!, request)
+        if (!verdict.allowed) {
+          yield {
+            type: 'error',
+            error: verdict.reason || 'Request blocked by DLP policy.',
+          }
+          return
+        }
+      }
+
       let assistantContent = ''
       let reasoningContent = ''
       let thinkingContent = ''
@@ -633,6 +723,9 @@ export class QueryEngine {
         backgroundAgentRegistry: getBackgroundAgentRegistry(),
       })
 
+      // Track touched files for rules matching
+      this.trackTouchedFile(name, effectiveParams)
+
       // Run PostToolUse hooks
       if (this.hookEngine) {
         await this.hookEngine.executePostToolUse(name, effectiveParams, result, 'session-1')

package/src/core/hooks.ts

@@ -155,6 +155,29 @@ export class HookEngine {
     return this.runHooks('PostToolUseFailure', toolName, ctx)
   }
 
+  /** PreInference: fires before every model API call for DLP inspection. */
+  async executePreInference(
+    messages: Array<{ role: string; content: string }>,
+    toolCalls: Array<{
+      name: string
+      input: Record<string, unknown>
+      resultPreview: string
+    }>,
+    sessionId: string,
+    provider: string,
+    model: string,
+  ): Promise<HookResult> {
+    const ctx: HookContext = {
+      event: 'PreInference',
+      sessionId,
+      messages,
+      toolCalls,
+      provider,
+      model,
+    }
+    return this.runHooks('PreInference', undefined, ctx)
+  }
+
   // ── Core execution ──
 
   private async runHooks(

package/src/core/inference-hook.ts

@@ -0,0 +1,224 @@
+import { createHmac, randomUUID } from 'node:crypto'
+import type {
+  InferenceHookConfig,
+  InferenceCheckRequest,
+  InferenceCheckResponse,
+  Message,
+} from '../shared/index.ts'
+
+// ── Result type ──
+
+export interface InferenceVerdict {
+  allowed: boolean
+  reason?: string
+}
+
+// ── Public API ──
+
+/**
+ * Build the inference-check request payload from current conversation state.
+ *
+ * Follows Claude Inference Hooks protocol:
+ * - Sends all messages EXCEPT system role (never expose system prompts)
+ * - Includes recent tool calls with result previews (truncated to 2000 chars)
+ * - Omits tool definitions and raw file/image content
+ */
+export function buildRequest(
+  messages: Message[],
+  sessionId: string,
+  provider: string,
+  model: string,
+  organizationId?: string,
+): InferenceCheckRequest {
+  // Filter: exclude system messages, flatten content blocks to text
+  const serialized: Array<{ role: string; content: string }> = []
+  for (const msg of messages) {
+    if (msg.role === 'system') continue
+    serialized.push({
+      role: msg.role,
+      content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+    })
+  }
+
+  // Extract tool calls from the message history
+  const toolCalls = extractToolCalls(messages)
+
+  return {
+    type: 'inference_check',
+    id: `evt_${randomUUID()}`,
+    created_at: new Date().toISOString(),
+    data: {
+      type: 'pre_inference',
+      session_id: sessionId,
+      organization_id: organizationId || undefined,
+      provider,
+      model,
+      messages: serialized,
+      tool_calls: toolCalls,
+    },
+  }
+}
+
+/**
+ * Send the inference-check request to the DLP server and return the verdict.
+ *
+ * On network error or timeout, applies the configured `on_failure` strategy:
+ * - 'fail-closed': block the request (security-first)
+ * - 'fail-open': allow the request (availability-first)
+ */
+export async function sendInferenceCheck(
+  config: InferenceHookConfig,
+  request: InferenceCheckRequest,
+): Promise<InferenceVerdict> {
+  const body = JSON.stringify(request)
+
+  // Build signature header
+  const signature = signPayload(config.signing_secret, body)
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'User-Agent': `MiphamCode/${getVersion()}`,
+    ...(config.headers || {}),
+  }
+
+  if (signature) {
+    headers['X-Mipham-Signature'] = signature
+  }
+
+  try {
+    const response = await fetch(config.endpoint, {
+      method: 'POST',
+      headers,
+      body,
+      signal: AbortSignal.timeout(config.timeout),
+    })
+
+    const responseBody = await response.text()
+
+    if (response.status === 200) {
+      // Parse verdict — treat any non-deny as allow
+      try {
+        const parsed = JSON.parse(responseBody) as InferenceCheckResponse
+        if (parsed.verdict === 'deny') {
+          return { allowed: false, reason: parsed.reason || 'Blocked by DLP policy' }
+        }
+        return { allowed: true }
+      } catch {
+        // Unparseable response — treat as allow (server acknowledged receipt)
+        return { allowed: true }
+      }
+    }
+
+    // 403 = explicit deny
+    if (response.status === 403) {
+      try {
+        const parsed = JSON.parse(responseBody) as InferenceCheckResponse
+        return { allowed: false, reason: parsed.reason || 'Blocked by DLP policy' }
+      } catch {
+        return { allowed: false, reason: `DLP server denied (403): ${responseBody.slice(0, 200)}` }
+      }
+    }
+
+    // Other non-2xx: apply failure posture
+    if (config.on_failure === 'fail-closed') {
+      return {
+        allowed: false,
+        reason: `DLP server returned ${response.status}: ${responseBody.slice(0, 200)}`,
+      }
+    }
+    return { allowed: true }
+  } catch (err) {
+    // Network error or timeout
+    if (config.on_failure === 'fail-closed') {
+      const msg = err instanceof Error ? err.message : String(err)
+      return {
+        allowed: false,
+        reason: `DLP server unreachable: ${msg}`,
+      }
+    }
+    // fail-open: allow through
+    return { allowed: true }
+  }
+}
+
+/**
+ * Check if inference hook is configured and should be used.
+ */
+export function isInferenceHookEnabled(config?: InferenceHookConfig): boolean {
+  return !!(config?.endpoint && config.endpoint.length > 0)
+}
+
+// ── Internal helpers ──
+
+/**
+ * Extract tool calls and their results from the entire message history.
+ * Scans for tool_use/tool_result pairs across all messages.
+ * Each result_preview is truncated to 2000 characters.
+ */
+function extractToolCalls(
+  messages: Message[],
+): Array<{ name: string; input: Record<string, unknown>; result_preview: string }> {
+  // Collect tool results first (keyed by tool_use_id)
+  const toolResults = new Map<string, string>()
+  for (const msg of messages) {
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === 'tool_result') {
+          toolResults.set(block.tool_use_id, block.content || '')
+        }
+      }
+    }
+  }
+
+  // Extract tool_use blocks with their result previews
+  const calls: Array<{
+    name: string
+    input: Record<string, unknown>
+    result_preview: string
+  }> = []
+
+  for (const msg of messages) {
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === 'tool_use') {
+          const resultPreview = toolResults.get(block.id) || ''
+          calls.push({
+            name: block.name,
+            input: block.input,
+            result_preview: resultPreview.slice(0, 2000),
+          })
+        }
+      }
+    }
+  }
+
+  return calls
+}
+
+/**
+ * Sign the request body using HMAC-SHA256.
+ * Follows Standard Webhooks specification:
+ *   X-Mipham-Signature: t=<unix_timestamp>,v1=<hmac_sha256_hex>
+ * Returns empty string if no signing secret is configured.
+ */
+function signPayload(secret: string, body: string): string {
+  if (!secret) return ''
+  const timestamp = Math.floor(Date.now() / 1000).toString()
+  const signedPayload = `${timestamp}.${body}`
+  const signature = createHmac('sha256', secret).update(signedPayload).digest('hex')
+  return `t=${timestamp},v1=${signature}`
+}
+
+/**
+ * Get the current package version for the User-Agent header.
+ */
+function getVersion(): string {
+  try {
+    // Dynamic import to avoid circular deps — the shared package-info
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const pkg = require('../../package.json') as { version?: string }
+    return pkg.version || '0.0.0'
+  } catch {
+    return '0.0.0'
+  }
+}