@miphamai/cli 0.10.0 → 0.12.0

package/src/core/metrics.ts

@@ -0,0 +1,364 @@
+/**
+ * Lightweight Prometheus-compatible metrics registry for mipham-code.
+ *
+ * Provides Counter, Gauge, and Histogram metric types compatible with
+ * the Python shared/metrics.py module in MegaSystem.  Metrics are
+ * collected in-memory and can be exported in Prometheus text format
+ * or JSON.
+ *
+ * Usage:
+ *   import { getMetrics } from '../core/metrics.js'
+ *
+ *   const m = getMetrics()
+ *   m.cliInvocations.inc()
+ *   m.toolCalls.inc({ tool_name: 'bash' })
+ *   m.modelRequestDuration.observe(150.0, { provider: 'anthropic' })
+ *
+ * Endpoints (via ArtifactServer):
+ *   GET /metrics      — Prometheus text format
+ *   GET /metrics/json — JSON format
+ */
+
+// ── Metric types ──────────────────────────────────────────────────────────
+
+export interface MetricLabels {
+  [key: string]: string
+}
+
+/** Format labels into Prometheus {...} string. */
+function formatLabels(labels?: MetricLabels): string {
+  if (!labels || Object.keys(labels).length === 0) return ''
+  const parts = Object.entries(labels)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${k}="${v.replace(/"/g, '\\"')}"`)
+  return `{${parts.join(',')}}`
+}
+
+// ── Counter ──────────────────────────────────────────────────────────────
+
+export class Counter {
+  readonly name: string
+  readonly help: string
+  readonly labels: MetricLabels
+  private _value = 0
+
+  constructor(name: string, help: string, labels?: MetricLabels) {
+    this.name = name
+    this.help = help
+    this.labels = labels ?? {}
+  }
+
+  inc(amount = 1): void {
+    this._value += amount
+  }
+
+  get value(): number {
+    return this._value
+  }
+
+  /** Full metric name with labels for dedup key. */
+  get key(): string {
+    return this.name + formatLabels(this.labels)
+  }
+
+  toPrometheus(): string {
+    const labelStr = formatLabels(this.labels)
+    return `${this.name}${labelStr} ${this._value}`
+  }
+
+  toJSON(): object {
+    return {
+      name: this.name,
+      type: 'counter',
+      help: this.help,
+      labels: this.labels,
+      value: this._value,
+    }
+  }
+}
+
+// ── Gauge ────────────────────────────────────────────────────────────────
+
+export class Gauge {
+  readonly name: string
+  readonly help: string
+  readonly labels: MetricLabels
+  private _value = 0
+
+  constructor(name: string, help: string, labels?: MetricLabels) {
+    this.name = name
+    this.help = help
+    this.labels = labels ?? {}
+  }
+
+  inc(amount = 1): void {
+    this._value += amount
+  }
+
+  dec(amount = 1): void {
+    this._value -= amount
+  }
+
+  set(value: number): void {
+    this._value = value
+  }
+
+  get value(): number {
+    return this._value
+  }
+
+  get key(): string {
+    return this.name + formatLabels(this.labels)
+  }
+
+  toPrometheus(): string {
+    const labelStr = formatLabels(this.labels)
+    return `${this.name}${labelStr} ${this._value}`
+  }
+
+  toJSON(): object {
+    return {
+      name: this.name,
+      type: 'gauge',
+      help: this.help,
+      labels: this.labels,
+      value: this._value,
+    }
+  }
+}
+
+// ── Histogram ────────────────────────────────────────────────────────────
+
+const DEFAULT_BUCKETS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]
+
+export class Histogram {
+  readonly name: string
+  readonly help: string
+  readonly labels: MetricLabels
+  readonly buckets: number[]
+  private _count = 0
+  private _sum = 0
+  private _bucketCounts: number[]
+
+  constructor(name: string, help: string, buckets?: number[], labels?: MetricLabels) {
+    this.name = name
+    this.help = help
+    this.labels = labels ?? {}
+    this.buckets = buckets ?? DEFAULT_BUCKETS
+    this._bucketCounts = new Array(this.buckets.length).fill(0)
+  }
+
+  observe(value: number): void {
+    this._count++
+    this._sum += value
+    for (let i = 0; i < this.buckets.length; i++) {
+      if (value <= (this.buckets[i] ?? Infinity)) {
+        this._bucketCounts[i] = (this._bucketCounts[i] ?? 0) + 1
+      }
+    }
+  }
+
+  get count(): number {
+    return this._count
+  }
+
+  get sum(): number {
+    return this._sum
+  }
+
+  get key(): string {
+    return this.name + formatLabels(this.labels)
+  }
+
+  toPrometheus(): string {
+    const labelStr = formatLabels(this.labels)
+    const lines: string[] = []
+
+    // _bucket values
+    for (let i = 0; i < this.buckets.length; i++) {
+      const bucketLabel = formatLabels({
+        ...this.labels,
+        le: String(this.buckets[i]),
+      })
+      lines.push(`${this.name}_bucket${bucketLabel} ${this._bucketCounts[i]}`)
+    }
+    // +Inf bucket
+    const infLabel = formatLabels({ ...this.labels, le: '+Inf' })
+    lines.push(`${this.name}_bucket${infLabel} ${this._count}`)
+
+    // _sum and _count
+    lines.push(`${this.name}_sum${labelStr} ${this._sum}`)
+    lines.push(`${this.name}_count${labelStr} ${this._count}`)
+
+    return lines.join('\n')
+  }
+
+  toJSON(): object {
+    const bucketResults: { le: string; count: number }[] = []
+    for (let i = 0; i < this.buckets.length; i++) {
+      bucketResults.push({ le: String(this.buckets[i]), count: this._bucketCounts[i] ?? 0 })
+    }
+    bucketResults.push({ le: '+Inf', count: this._count })
+    return {
+      name: this.name,
+      type: 'histogram',
+      help: this.help,
+      labels: this.labels,
+      count: this._count,
+      sum: this._sum,
+      buckets: bucketResults,
+    }
+  }
+}
+
+// ── MetricsRegistry ──────────────────────────────────────────────────────
+
+export class MetricsRegistry {
+  private _counters = new Map<string, Counter>()
+  private _gauges = new Map<string, Gauge>()
+  private _histograms = new Map<string, Histogram>()
+
+  // ── Predefined metrics ─────────────────────────────────────────
+
+  /** CLI invocation counter. Incremented on each CLI startup. */
+  readonly cliInvocations: Counter
+
+  /** Tool call counter, labelled by tool_name.  Callers use .inc({tool_name}). */
+  readonly toolCalls: Counter
+
+  /** Model API request counter, labelled by provider and model. */
+  readonly modelRequests: Counter
+
+  /** Model API request error counter, labelled by provider and error type. */
+  readonly modelRequestErrors: Counter
+
+  /** Model API request latency histogram (milliseconds). */
+  readonly modelRequestDurationMs: Histogram
+
+  /** Active CLI sessions gauge. */
+  readonly activeSessions: Gauge
+
+  constructor() {
+    // Pre-register standard metrics
+    this.cliInvocations = this.counter(
+      'mipham_code_cli_invocations_total',
+      'Number of CLI invocations',
+    )
+
+    this.toolCalls = this.counter('mipham_code_tool_calls_total', 'Number of tool invocations')
+
+    this.modelRequests = this.counter(
+      'mipham_code_model_requests_total',
+      'Number of model API requests',
+    )
+
+    this.modelRequestErrors = this.counter(
+      'mipham_code_model_request_errors_total',
+      'Number of model API request errors',
+    )
+
+    this.modelRequestDurationMs = this.histogram(
+      'mipham_code_model_request_duration_ms',
+      'Model API request duration in milliseconds',
+      [50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000, 60000],
+    )
+
+    this.activeSessions = this.gauge('mipham_code_active_sessions', 'Number of active CLI sessions')
+  }
+
+  // ── Factory methods ─────────────────────────────────────────────
+
+  counter(name: string, help: string, labels?: MetricLabels): Counter {
+    const c = new Counter(name, help, labels)
+    if (this._counters.has(c.key)) return this._counters.get(c.key)!
+    this._counters.set(c.key, c)
+    return c
+  }
+
+  gauge(name: string, help: string, labels?: MetricLabels): Gauge {
+    const g = new Gauge(name, help, labels)
+    if (this._gauges.has(g.key)) return this._gauges.get(g.key)!
+    this._gauges.set(g.key, g)
+    return g
+  }
+
+  histogram(name: string, help: string, buckets?: number[], labels?: MetricLabels): Histogram {
+    const h = new Histogram(name, help, buckets, labels)
+    if (this._histograms.has(h.key)) return this._histograms.get(h.key)!
+    this._histograms.set(h.key, h)
+    return h
+  }
+
+  // ── Export ──────────────────────────────────────────────────────
+
+  /** Export all metrics in Prometheus text format. */
+  toPrometheusText(): string {
+    const lines: string[] = []
+    const seen = new Set<string>()
+
+    for (const c of this._counters.values()) {
+      if (!seen.has(c.name)) {
+        lines.push(`# HELP ${c.name} ${c.help}`)
+        lines.push(`# TYPE ${c.name} counter`)
+        seen.add(c.name)
+      }
+      lines.push(c.toPrometheus())
+    }
+
+    for (const g of this._gauges.values()) {
+      if (!seen.has(g.name)) {
+        lines.push(`# HELP ${g.name} ${g.help}`)
+        lines.push(`# TYPE ${g.name} gauge`)
+        seen.add(g.name)
+      }
+      lines.push(g.toPrometheus())
+    }
+
+    for (const h of this._histograms.values()) {
+      if (!seen.has(h.name)) {
+        lines.push(`# HELP ${h.name} ${h.help}`)
+        lines.push(`# TYPE ${h.name} histogram`)
+        seen.add(h.name)
+      }
+      lines.push(h.toPrometheus())
+    }
+
+    return lines.join('\n') + '\n'
+  }
+
+  /** Export all metrics as JSON. */
+  toJSON(): object {
+    return {
+      counters: Array.from(this._counters.values()).map((c) => c.toJSON()),
+      gauges: Array.from(this._gauges.values()).map((g) => g.toJSON()),
+      histograms: Array.from(this._histograms.values()).map((h) => h.toJSON()),
+    }
+  }
+
+  /** Reset all metrics (useful for testing). */
+  reset(): void {
+    this._counters.clear()
+    this._gauges.clear()
+    this._histograms.clear()
+  }
+}
+
+// ── Singleton ────────────────────────────────────────────────────────────
+
+let _instance: MetricsRegistry | null = null
+
+/** Get the global MetricsRegistry singleton. */
+export function getMetrics(): MetricsRegistry {
+  if (!_instance) {
+    _instance = new MetricsRegistry()
+  }
+  return _instance
+}
+
+/** Reset the singleton (useful for testing). */
+export function resetMetrics(): void {
+  if (_instance) {
+    _instance.reset()
+    _instance = null
+  }
+}

package/src/core/output-styles.ts

@@ -0,0 +1,95 @@
+/**
+ * OutputStylesLoader — loads custom response persona styles from .mipham/output-styles/.
+ *
+ * Each .md file in the directory is a named style. The active style's content
+ * is injected into the system prompt to shape the AI's tone and communication style.
+ *
+ * Usage:
+ *   const loader = new OutputStylesLoader(cwd)
+ *   loader.list()               // ['concise', 'academic', ...]
+ *   loader.get('concise')       // style content or undefined
+ *   loader.setActive('concise') // switch active style
+ *   loader.getActiveContent()   // active style content (for system prompt)
+ */
+
+import { readdirSync, readFileSync, existsSync } from 'node:fs'
+import { join, basename, extname } from 'node:path'
+
+export class OutputStylesLoader {
+  private stylesDir: string
+  private activeStyle: string | null = null
+
+  constructor(cwd: string) {
+    this.stylesDir = join(cwd, '.mipham', 'output-styles')
+  }
+
+  /**
+   * List all available style names (filename without .md extension).
+   */
+  list(): string[] {
+    if (!existsSync(this.stylesDir)) return []
+    try {
+      return readdirSync(this.stylesDir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => basename(f, extname(f)))
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Get the content of a named style. Returns undefined if not found.
+   */
+  get(name: string): string | undefined {
+    if (!existsSync(this.stylesDir)) return undefined
+    const filepath = join(this.stylesDir, `${name}.md`)
+    if (!existsSync(filepath)) return undefined
+    try {
+      return readFileSync(filepath, 'utf-8').trim()
+    } catch {
+      return undefined
+    }
+  }
+
+  /**
+   * Set the active output style.
+   */
+  setActive(name: string): boolean {
+    const content = this.get(name)
+    if (!content) return false
+    this.activeStyle = name
+    return true
+  }
+
+  /**
+   * Clear the active output style (revert to default personality).
+   */
+  clearActive(): void {
+    this.activeStyle = null
+  }
+
+  /**
+   * Get the active style name (null if none selected).
+   */
+  getActiveName(): string | null {
+    return this.activeStyle
+  }
+
+  /**
+   * Get the active style content for system prompt injection.
+   * Returns empty string if no style is active.
+   */
+  getActiveContent(): string {
+    if (!this.activeStyle) return ''
+    const content = this.get(this.activeStyle)
+    if (!content) return ''
+    return [
+      `[Output Style: ${this.activeStyle}]`,
+      'Adopt the following communication style in all your responses:',
+      '',
+      content,
+      '',
+      '---',
+    ].join('\n')
+  }
+}

package/src/core/rules-loader.ts

@@ -0,0 +1,175 @@
+/**
+ * RulesLoader — path-scoped rules from .mipham/rules/.
+ *
+ * Rules are markdown files with YAML frontmatter. They are injected into
+ * the conversation when the AI touches matching files.
+ *
+ * Directory structure:
+ *   .mipham/rules/
+ *     always.md        — always loaded (no paths filter)
+ *     typescript.md    — loaded when touching *.ts files
+ *     security.md      — loaded when touching auth/ or crypto/ paths
+ *
+ * Frontmatter:
+ *   ---
+ *   paths: "apps/cli/src/**\/*.ts"
+ *   description: TypeScript coding standards
+ *   ---
+ */
+
+import { readdirSync, readFileSync, existsSync } from 'node:fs'
+import { join, relative } from 'node:path'
+
+interface RuleFile {
+  name: string
+  paths: string[] // glob patterns, empty = always loaded
+  description: string
+  content: string
+}
+
+export class RulesLoader {
+  private rules: RuleFile[] = []
+  private rulesDir: string
+
+  constructor(cwd: string) {
+    this.rulesDir = join(cwd, '.mipham', 'rules')
+  }
+
+  /**
+   * Load all rules from .mipham/rules/. Call once at startup.
+   */
+  load(): void {
+    this.rules = []
+    if (!existsSync(this.rulesDir)) return
+
+    try {
+      const files = readdirSync(this.rulesDir).filter((f) => f.endsWith('.md'))
+      for (const file of files) {
+        const filepath = join(this.rulesDir, file)
+        try {
+          const raw = readFileSync(filepath, 'utf-8')
+          const { paths, description, content } = this.parseRule(raw, file)
+          this.rules.push({ name: file.replace(/\.md$/, ''), paths, description, content })
+        } catch {
+          // Skip unparseable files
+        }
+      }
+    } catch {
+      // Directory read error — rules unavailable
+    }
+  }
+
+  /**
+   * Get rules that match the given file paths.
+   * Rules with no paths filter ("always") are always included.
+   */
+  getMatchingRules(touchedFiles: string[]): RuleFile[] {
+    const matched: RuleFile[] = []
+
+    for (const rule of this.rules) {
+      // Always rules — no paths filter
+      if (rule.paths.length === 0) {
+        matched.push(rule)
+        continue
+      }
+
+      // Check if any touched file matches any rule path pattern
+      for (const file of touchedFiles) {
+        for (const pattern of rule.paths) {
+          if (this.matchPath(file, pattern)) {
+            matched.push(rule)
+            // Break inner loops — rule already matched
+            break
+          }
+        }
+        if (matched.includes(rule)) break
+      }
+    }
+
+    return matched
+  }
+
+  /**
+   * Build a context block to inject into the conversation.
+   */
+  buildContextBlock(touchedFiles: string[]): string {
+    const matched = this.getMatchingRules(touchedFiles)
+    if (matched.length === 0) return ''
+
+    const blocks = matched.map(
+      (r) => `[Rule: ${r.name}]${r.description ? ` — ${r.description}` : ''}\n${r.content}`,
+    )
+    return `\n<!-- Path-scoped rules matching: ${touchedFiles.join(', ')} -->\n${blocks.join('\n\n')}\n`
+  }
+
+  /**
+   * Count loaded rules.
+   */
+  count(): number {
+    return this.rules.length
+  }
+
+  /**
+   * List loaded rule names.
+   */
+  list(): string[] {
+    return this.rules.map((r) => r.name)
+  }
+
+  /**
+   * Simple glob matching. Supports **, *, and exact file matching.
+   * Returns true if file matches pattern.
+   */
+  private matchPath(file: string, pattern: string): boolean {
+    // Convert glob pattern to regex
+    let regexStr = pattern
+      .replace(/\./g, '\\.')
+      .replace(/\*\*/g, '<<GLOBSTAR>>')
+      .replace(/\*/g, '[^/]*')
+      .replace(/<<GLOBSTAR>>/g, '.*')
+
+    // If pattern doesn't start with ** or *, anchor to be a suffix match
+    if (!pattern.startsWith('**') && !pattern.startsWith('*')) {
+      regexStr = regexStr + '$'
+    }
+
+    try {
+      return new RegExp(regexStr).test(file)
+    } catch {
+      // Invalid pattern — fallback to simple includes
+      return file.includes(pattern.replace(/\*\*/g, '').replace(/\*/g, ''))
+    }
+  }
+
+  /**
+   * Parse a rule file — extract frontmatter and body.
+   */
+  private parseRule(
+    raw: string,
+    filename: string,
+  ): { paths: string[]; description: string; content: string } {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/)
+    if (!match) {
+      return { paths: [], description: '', content: raw.trim() }
+    }
+
+    const frontmatter = match[1] || ''
+    const body = (match[2] || '').trim()
+
+    const paths: string[] = []
+    let description = ''
+
+    for (const line of frontmatter.split('\n')) {
+      const pathMatch = line.match(/^paths:\s*"(.+)"$/)
+      if (pathMatch) {
+        pathMatch[1]!.split(',').forEach((p) => paths.push(p.trim()))
+      }
+      const descMatch = line.match(/^description:\s*(.+)$/)
+      if (descMatch) {
+        description = descMatch[1]!.trim()
+      }
+    }
+
+    return { paths, description, content: body }
+  }
+}

package/src/index.tsx

@@ -1,7 +1,7 @@
 import { join } from 'node:path'
 import { render } from 'ink'
 import { App } from './ui/app'
-import { loadConfig } from './config/loader'
+import { loadConfig, loadInferenceHookConfig } from './config/loader'
 import { bootstrapProviders } from './providers/bootstrap'
 import { InstructionsLoader } from './core/instructions'
 import { loadSessionMemories } from './core/memory/memory-loader'
@@ -18,6 +18,7 @@ import { registerMcpServerTools } from './mcp/registry'
 import { AgentRegistry } from './agent/agent-registry'
 import { HookEngine } from './core/hooks'
 import { ArtifactServer } from './artifacts/server'
+import { getMetrics } from './core/metrics'
 import { ARTIFACTS_DIR, ARTIFACT_PORT, MIPHAM_DIR } from './shared/constants'
 import { AgentViewManager } from './agent-view/agent-view-manager'
 import { AgentViewDashboard } from './agent-view/dashboard'
@@ -32,6 +33,9 @@ interface RunOptions {
 }
 
 export async function runApp(options: RunOptions): Promise<void> {
+  // Metrics: count CLI invocation
+  getMetrics().cliInvocations.inc()
+
   // Handle `mipham agents` subcommand — launch standalone dashboard
   const args = process.argv.slice(2)
   if (args[0] === 'agents') {
@@ -149,6 +153,10 @@ export async function runApp(options: RunOptions): Promise<void> {
   engine.setAgentViewManager(agentViewManager)
   engine.setSkillsLoader(skillsLoader)
 
+  // Wire inference hooks (DLP) configuration
+  const inferenceHookConfig = loadInferenceHookConfig()
+  engine.setInferenceHookConfig(inferenceHookConfig)
+
   // Sync engine permission with config (fix: UI shows "auto" but engine defaulted to bypass-legacy)
   if (config.permission) {
     engine.getPermission().setDefaultLevel(config.permission as PermissionLevel)

package/src/mcp/client.ts

@@ -151,6 +151,15 @@ export class McpClient {
     return this.connections.get(name)?.tools || []
   }
 
+  /** List all currently connected MCP server names. */
+  getConnectedServers(): string[] {
+    const names: string[] = []
+    for (const [name, conn] of this.connections) {
+      if (conn.status === 'connected') names.push(name)
+    }
+    return names
+  }
+
   async callTool(
     serverName: string,
     toolName: string,