@miphamai/cli 0.2.3

package/skills/standard/security-review.SKILL.md

@@ -0,0 +1,122 @@
+---
+name: security-review
+description: Security audit skill — vulnerability scanning, OWASP Top 10, secrets detection, supply chain analysis, and compliance checking
+version: 1.0.0
+---
+
+# Security Review
+
+Comprehensive security audit for codebases. Covers vulnerability detection, compliance, and hardening recommendations.
+
+## Audit Checklist
+
+### 1. Secrets & Credentials
+
+- [ ] No hardcoded API keys, tokens, or passwords in source files
+- [ ] `.env` and `*.pem` files in `.gitignore`
+- [ ] API keys use environment variables or secret managers
+- [ ] No credentials in git history (check `git log -p`)
+- [ ] CI/CD secrets stored securely (not in workflow files)
+
+### 2. OWASP Top 10
+
+- [ ] **Injection**: SQL, NoSQL, OS command, LDAP injection points
+- [ ] **Broken Authentication**: Weak password policies, missing MFA
+- [ ] **Sensitive Data Exposure**: Unencrypted PII, missing TLS
+- [ ] **XXE**: XML external entity processing
+- [ ] **Broken Access Control**: Missing authorization checks
+- [ ] **Security Misconfiguration**: Default credentials, verbose errors
+- [ ] **XSS**: Reflected, stored, DOM-based cross-site scripting
+- [ ] **Insecure Deserialization**: Untrusted data deserialization
+- [ ] **Using Vulnerable Components**: Outdated dependencies with CVEs
+- [ ] **Insufficient Logging**: Missing audit trails for auth events
+
+### 3. Supply Chain
+
+- [ ] All dependencies have known licenses (no copyleft/GPL)
+- [ ] No dependencies with critical CVEs
+- [ ] Lock files committed (pnpm-lock.yaml, package-lock.json)
+- [ ] Dependency update policy in place
+- [ ] SBOM (Software Bill of Materials) available
+
+### 4. Network & API Security
+
+- [ ] TLS 1.3 enforced for all external communications
+- [ ] API endpoints have rate limiting
+- [ ] CORS configured with explicit origins (not `*`)
+- [ ] SSRF protections in place (URL validation, IP filtering)
+- [ ] WebSocket connections use WSS
+- [ ] GraphQL endpoints have query depth limits
+
+### 5. File System & Path Security
+
+- [ ] Path traversal protections (no `../../../etc/passwd`)
+- [ ] File upload validation (type, size, content inspection)
+- [ ] Symlink attacks prevented
+- [ ] Sensitive directories blocked (`/etc`, `/proc`, `/sys`)
+- [ ] Temporary files cleaned up after use
+
+### 6. Code-Level Security
+
+- [ ] No `eval()` or `Function()` with user input
+- [ ] No `child_process.exec()` with unsanitized input
+- [ ] Regex patterns safe from ReDoS
+- [ ] Prototype pollution prevented
+- [ ] No `dangerouslySetInnerHTML` without sanitization (React)
+- [ ] SQL queries use parameterized statements
+
+### 7. Authentication & Sessions
+
+- [ ] Passwords hashed with bcrypt/argon2 (not MD5/SHA1)
+- [ ] Session tokens use `httpOnly`, `secure`, `SameSite=Strict`
+- [ ] JWT tokens have reasonable expiration
+- [ ] Account lockout after failed attempts
+- [ ] Password reset tokens expire and are single-use
+
+### 8. Data Protection
+
+- [ ] PII data encrypted at rest (AES-256-GCM)
+- [ ] Data encrypted in transit (TLS 1.3)
+- [ ] Logs do not contain sensitive data
+- [ ] Database backups encrypted
+- [ ] Data retention policies defined
+
+### 9. Infrastructure
+
+- [ ] Infrastructure as Code (Terraform/Pulumi) used
+- [ ] Cloud resources not publicly exposed unless intended
+- [ ] Security groups / firewalls restrict inbound traffic
+- [ ] Container images scanned for vulnerabilities
+- [ ] Kubernetes pods run as non-root
+
+### 10. Logging & Monitoring
+
+- [ ] Authentication events logged
+- [ ] Failed access attempts logged and alerted
+- [ ] Structured logging format (JSON)
+- [ ] No PII in log messages
+- [ ] Alert thresholds configured for critical events
+
+## Report Format
+
+```
+Security Review Report
+======================
+Date: YYYY-MM-DD
+Severity: Critical | High | Medium | Low
+
+Finding #N: [Title]
+Severity: Critical/High/Medium/Low
+Location: file:line
+Description: [What was found]
+Risk: [What could happen]
+Fix: [How to resolve]
+```
+
+## Compliance Standards
+
+- OWASP ASVS Level 2
+- PCI DSS (if handling payment data)
+- GDPR (if handling EU personal data)
+- SOC 2 Type II
+- ISO 27001

package/skills/standard/self-review.SKILL.md

@@ -0,0 +1,20 @@
+---
+name: self-review
+description: Review the current diff for correctness bugs and reuse/simplification efficiency cleanups
+version: 1.0.0
+---
+
+# Self Review Skill
+
+Review changed code for reuse, simplification, efficiency, and altitude cleanups. Quality only — it does not hunt for bugs.
+
+## Review Focus
+
+- Code reuse opportunities
+- Simplification: reduce complexity
+- Efficiency: performance improvements
+- Altitude: architectural alignment
+
+## Output
+
+Apply fixes where appropriate. Explain reasoning for each change.

package/skills/standard/superpower.SKILL.md

@@ -0,0 +1,19 @@
+---
+name: superpower
+description: Use when starting any conversation — establishes how to find and use skills
+version: 1.0.0
+---
+
+# Superpowers Skill
+
+## Instruction Priority
+
+User's explicit instructions always take precedence.
+
+## How to Access Skills
+
+Use the Skill tool to invoke skills. When you invoke a skill, its content is loaded and presented to you — follow it directly.
+
+## The Rule
+
+Invoke relevant or requested skills BEFORE any response or action. Even a 1% chance a skill might apply means that you should invoke the skill to check.

package/skills/standard/tdd.SKILL.md

@@ -0,0 +1,20 @@
+---
+name: tdd
+description: Test-Driven Development workflow — red, green, refactor
+version: 1.0.0
+---
+
+# TDD Skill
+
+## Workflow
+
+1. **Red**: Write a failing test that defines the expected behavior
+2. **Green**: Write the minimum code to make the test pass
+3. **Refactor**: Clean up the code while tests remain green
+
+## Rules
+
+- Never write production code without a failing test
+- Write only enough test to fail
+- Write only enough code to pass
+- Tests must be deterministic and isolated

package/skills/standard/web-search.SKILL.md

@@ -0,0 +1,23 @@
+---
+name: web-search
+description: Search the web for current information, documentation, and news
+version: 1.0.0
+---
+
+# Web Search Skill
+
+Use WebSearch tool to find current information.
+
+## When to Use
+
+- Up-to-date documentation for libraries and frameworks
+- Current events and news
+- Technical troubleshooting with recent solutions
+- API reference and version-specific features
+
+## Best Practices
+
+- Be specific with search queries
+- Use allowed_domains to focus results
+- Verify information from multiple sources
+- Cite sources in responses

package/src/agent/sub-agent.ts

@@ -0,0 +1,122 @@
+import { ContextManager } from '../core/context'
+import type { ProviderRegistry } from '../providers/registry'
+import type { Message } from '../shared/types'
+
+export type SubAgentType = 'general' | 'explore' | 'plan' | 'code-review'
+
+interface SubAgentOptions {
+  type?: SubAgentType
+  systemPrompt?: string
+  maxContextMessages?: number
+}
+
+const TYPE_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
+  general: 'You are a focused sub-agent. Complete the assigned task thoroughly and return results.',
+  explore:
+    'You are an exploration sub-agent. Search, read, and analyze code. Return structured findings with file paths and line numbers.',
+  plan: 'You are a planning sub-agent. Design implementation approaches. Return a step-by-step plan with files to modify.',
+  'code-review':
+    'You are a code review sub-agent. Find bugs, security issues, and code quality problems. Return findings by severity.',
+}
+
+/**
+ * Sub-agent engine — creates an isolated conversation context and processes
+ * a single prompt independently. Returns the consolidated result.
+ *
+ * Phase 7: Pipeline-ready. Without a real AI provider, returns a structured
+ * analysis of the prompt. Full AI integration in M3.
+ */
+export class SubAgent {
+  constructor(private registry: ProviderRegistry) {}
+
+  async execute(
+    prompt: string,
+    description: string,
+    options: SubAgentOptions = {},
+  ): Promise<string> {
+    const type = options.type || 'general'
+    const systemPrompt = options.systemPrompt || TYPE_SYSTEM_PROMPTS[type]
+
+    // Create isolated context for this sub-agent
+    const context = new ContextManager({
+      maxTokens: 100_000,
+      compactionThreshold: 0.9,
+    })
+    context.setSystemPrompt(systemPrompt)
+    context.addMessage({ role: 'user', content: prompt })
+
+    // Phase 7 pipeline: attempt real AI, fall back to structured simulation
+    try {
+      const provider = this.registry.getActive()
+      if (provider) {
+        const messages = context.getMessages()
+        const chunks: string[] = []
+
+        for await (const chunk of provider.chat({
+          model: this.registry.getActiveModel(),
+          messages,
+          systemPrompt,
+          maxTokens: 4096,
+        })) {
+          if (chunk.type === 'text' && chunk.content) {
+            chunks.push(chunk.content)
+          }
+          if (chunk.type === 'error') {
+            // Fall through to simulation on API error
+            throw new Error(chunk.error)
+          }
+        }
+
+        if (chunks.length > 0) {
+          return chunks.join('')
+        }
+      }
+    } catch {
+      // API unavailable — use simulation mode
+    }
+
+    // Simulation mode: return structured task analysis
+    return this.simulate(prompt, description, type)
+  }
+
+  private simulate(prompt: string, description: string, type: SubAgentType): string {
+    const lines: string[] = [
+      `── Sub-Agent Result (${type}) ──`,
+      '',
+      `Task: ${description}`,
+      `Prompt: ${prompt.slice(0, 200)}${prompt.length > 200 ? '...' : ''}`,
+      '',
+    ]
+
+    switch (type) {
+      case 'explore':
+        lines.push(
+          'Analysis: This exploration task would search the codebase for relevant',
+          'files, patterns, and structures. The sub-agent pipeline is ready — connect',
+          'a provider API key for real AI-powered exploration.',
+        )
+        break
+      case 'plan':
+        lines.push(
+          'Plan: A step-by-step implementation plan would be generated based on',
+          'the requirements. Use /plan mode for interactive planning.',
+        )
+        break
+      case 'code-review':
+        lines.push(
+          'Review: The code review sub-agent would analyze the specified files for',
+          'bugs, security issues, and code quality concerns. Use /review for',
+          'interactive code review.',
+        )
+        break
+      default:
+        lines.push(
+          'The sub-agent pipeline is operational. Connect an API key to enable',
+          'AI-powered sub-agent execution. The infrastructure for context isolation,',
+          'prompt routing, and result aggregation is in place.',
+        )
+    }
+
+    return lines.join('\n')
+  }
+}

package/src/config/defaults.ts

@@ -0,0 +1,10 @@
+import type { MiphamConfig } from '../shared/index.ts'
+import { DEFAULT_PROVIDERS } from '../shared/index.ts'
+
+export const DEFAULT_CONFIG: MiphamConfig = {
+  version: '0.1.0',
+  defaultProvider: 'anthropic',
+  defaultModel: 'claude-sonnet-4-6',
+  permission: 'auto',
+  providers: DEFAULT_PROVIDERS,
+}

package/src/config/loader.ts

@@ -0,0 +1,30 @@
+import { readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { parse as parseYaml } from 'yaml'
+import type { MiphamConfig } from '../shared/index.ts'
+import { DEFAULT_CONFIG } from './defaults'
+
+export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
+  const configPath = join(cwd, '.mipham', 'config.yml')
+  const userConfigPath = join(process.env.HOME || '~', '.mipham', 'config.yml')
+
+  let config = { ...DEFAULT_CONFIG }
+
+  if (existsSync(configPath)) {
+    const raw = readFileSync(configPath, 'utf-8')
+    const projectConfig = parseYaml(raw) as Partial<MiphamConfig>
+    config = mergeConfig(config, projectConfig)
+  }
+
+  if (existsSync(userConfigPath)) {
+    const raw = readFileSync(userConfigPath, 'utf-8')
+    const userConfig = parseYaml(raw) as Partial<MiphamConfig>
+    config = mergeConfig(config, userConfig)
+  }
+
+  return config
+}
+
+function mergeConfig(base: MiphamConfig, override: Partial<MiphamConfig>): MiphamConfig {
+  return { ...base, ...override, providers: override.providers ?? base.providers }
+}

package/src/core/context.ts

@@ -0,0 +1,135 @@
+import type { Message } from '../shared/index.ts'
+
+interface ContextConfig {
+  maxTokens: number
+  compactionThreshold: number // e.g. 0.9 → compact at 90% usage
+}
+
+interface Checkpoint {
+  id: number
+  messages: Message[]
+  estimatedTokens: number
+  timestamp: Date
+  label: string
+}
+
+export class ContextManager {
+  private messages: Message[] = []
+  private systemPrompt = ''
+  private estimatedTokens = 0
+  private checkpoints: Checkpoint[] = []
+  private checkpointCounter = 0
+
+  constructor(private config: ContextConfig) {}
+
+  setSystemPrompt(prompt: string): void {
+    this.systemPrompt = prompt
+    this.estimatedTokens = this.estimateTokens(prompt)
+  }
+
+  getSystemPrompt(): string {
+    return this.systemPrompt
+  }
+
+  addMessage(msg: Message): void {
+    this.messages.push(msg)
+    this.estimatedTokens += this.estimateTokens(
+      typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+    )
+  }
+
+  getMessages(): Message[] {
+    return [...this.messages]
+  }
+
+  needsCompaction(): boolean {
+    return this.estimatedTokens > this.config.maxTokens * this.config.compactionThreshold
+  }
+
+  async compact(_summarizeHeading: string): Promise<void> {
+    // Phase 1: simple truncation — keep last 20 messages, drop oldest
+    if (this.messages.length > 30) {
+      const keep = 20
+      this.messages = this.messages.slice(-keep)
+
+      // Re-estimate tokens
+      this.estimatedTokens = this.estimateTokens(this.systemPrompt)
+      for (const msg of this.messages) {
+        this.estimatedTokens += this.estimateTokens(
+          typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+        )
+      }
+    }
+  }
+
+  getEstimatedTokens(): number {
+    return this.estimatedTokens
+  }
+
+  clear(): void {
+    this.messages = []
+    this.checkpoints = []
+    this.checkpointCounter = 0
+    this.estimatedTokens = this.estimateTokens(this.systemPrompt)
+  }
+
+  getMessageCount(): number {
+    return this.messages.length
+  }
+
+  // ── Checkpoint / Rewind ──
+
+  saveCheckpoint(label = 'auto'): number {
+    this.checkpointCounter++
+    const checkpoint: Checkpoint = {
+      id: this.checkpointCounter,
+      messages: structuredClone(this.messages),
+      estimatedTokens: this.estimatedTokens,
+      timestamp: new Date(),
+      label,
+    }
+    this.checkpoints.push(checkpoint)
+    // Keep only last 10 checkpoints
+    if (this.checkpoints.length > 10) {
+      this.checkpoints = this.checkpoints.slice(-10)
+    }
+    return checkpoint.id
+  }
+
+  restoreCheckpoint(checkpointId?: number): {
+    restored: boolean
+    messageCount: number
+    label: string
+  } {
+    // If no id given, restore the most recent checkpoint
+    const target = checkpointId
+      ? this.checkpoints.find((cp) => cp.id === checkpointId)
+      : this.checkpoints.at(-1)
+
+    if (!target) {
+      return { restored: false, messageCount: this.messages.length, label: '' }
+    }
+
+    this.messages = structuredClone(target.messages)
+    this.estimatedTokens = target.estimatedTokens
+    return { restored: true, messageCount: this.messages.length, label: target.label }
+  }
+
+  getCheckpoints(): Array<{ id: number; messageCount: number; timestamp: Date; label: string }> {
+    return this.checkpoints.map((cp) => ({
+      id: cp.id,
+      messageCount: cp.messages.length,
+      timestamp: cp.timestamp,
+      label: cp.label,
+    }))
+  }
+
+  getLastCheckpointId(): number | undefined {
+    return this.checkpoints.at(-1)?.id
+  }
+
+  private estimateTokens(text: string): number {
+    // Simple estimation: ~4 chars per token
+    return Math.ceil(text.length / 4)
+  }
+}

package/src/core/engine.ts

@@ -0,0 +1,193 @@
+import type { Message, StreamChunk, ToolDefinition, ToolResult } from '../shared/index.ts'
+import { ProviderRegistry } from '../providers/registry'
+import { ContextManager } from './context'
+import { PermissionSystem } from './permission'
+
+export class QueryEngine {
+  constructor(
+    private registry: ProviderRegistry,
+    private context: ContextManager,
+    private tools: Map<string, ToolDefinition>,
+    private permission: PermissionSystem = new PermissionSystem('bypass'),
+  ) {}
+
+  getPermission(): PermissionSystem {
+    return this.permission
+  }
+
+  async *process(userInput: string): AsyncGenerator<StreamChunk> {
+    // Add user message to context
+    this.context.addMessage({ role: 'user', content: userInput })
+
+    // Check compaction before processing
+    if (this.context.needsCompaction()) {
+      await this.context.compact('conversation summary')
+    }
+
+    const systemPrompt = this.context.getSystemPrompt()
+    const messages = this.context.getMessages()
+    const toolDefs = this.getToolDefinitions()
+
+    let assistantContent = ''
+    const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
+
+    // Stream model response
+    for await (const chunk of this.registry.chat({
+      model: this.registry.getActiveModel(),
+      messages,
+      systemPrompt,
+      tools: toolDefs.length > 0 ? toolDefs : undefined,
+    })) {
+      yield chunk
+
+      if (chunk.type === 'error') {
+        this.context.addMessage({ role: 'assistant', content: `Error: ${chunk.error}` })
+        return
+      }
+
+      if (chunk.type === 'text' && chunk.content) {
+        assistantContent += chunk.content
+      }
+
+      if (chunk.type === 'tool_use' && chunk.toolUse) {
+        toolUses.push({
+          id: chunk.toolUse.id,
+          name: chunk.toolUse.name,
+          input: chunk.toolUse.input,
+        })
+      }
+
+      if (chunk.type === 'stop') {
+        // Add assistant response to context
+        if (assistantContent) {
+          this.context.addMessage({ role: 'assistant', content: assistantContent })
+        }
+      }
+    }
+
+    // Execute any tools that were requested
+    for (const toolUse of toolUses) {
+      const result = await this.executeTool(toolUse.name, toolUse.input)
+      yield {
+        type: 'tool_result',
+        tool_use_id: toolUse.id,
+        content: result.content,
+      }
+
+      // Add tool use + result to context
+      this.context.addMessage({
+        role: 'assistant',
+        content: [{ type: 'tool_use', id: toolUse.id, name: toolUse.name, input: toolUse.input }],
+      })
+      this.context.addMessage({
+        role: 'user',
+        content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: result.content }],
+      })
+    }
+
+    // If tools were executed, recursively continue the conversation
+    if (toolUses.length > 0) {
+      yield* this.continueWithTools()
+    }
+  }
+
+  private async *continueWithTools(): AsyncGenerator<StreamChunk> {
+    const systemPrompt = this.context.getSystemPrompt()
+    const messages = this.context.getMessages()
+    const toolDefs = this.getToolDefinitions()
+
+    let assistantContent = ''
+    const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
+
+    for await (const chunk of this.registry.chat({
+      model: this.registry.getActiveModel(),
+      messages,
+      systemPrompt,
+      tools: toolDefs.length > 0 ? toolDefs : undefined,
+    })) {
+      yield chunk
+
+      if (chunk.type === 'error') return
+      if (chunk.type === 'text' && chunk.content) assistantContent += chunk.content
+
+      if (chunk.type === 'tool_use' && chunk.toolUse) {
+        toolUses.push({
+          id: chunk.toolUse.id,
+          name: chunk.toolUse.name,
+          input: chunk.toolUse.input,
+        })
+      }
+    }
+
+    if (assistantContent) {
+      this.context.addMessage({ role: 'assistant', content: assistantContent })
+    }
+
+    // Execute tools (max 1 level of recursion to prevent infinite loops)
+    for (const toolUse of toolUses) {
+      const result = await this.executeTool(toolUse.name, toolUse.input)
+      yield {
+        type: 'tool_result',
+        tool_use_id: toolUse.id,
+        content: result.content,
+      }
+
+      this.context.addMessage({
+        role: 'assistant',
+        content: [{ type: 'tool_use', id: toolUse.id, name: toolUse.name, input: toolUse.input }],
+      })
+      this.context.addMessage({
+        role: 'user',
+        content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: result.content }],
+      })
+    }
+  }
+
+  private async executeTool(name: string, params: Record<string, unknown>): Promise<ToolResult> {
+    const tool = this.tools.get(name)
+    if (!tool) {
+      return { success: false, content: '', error: `Unknown tool: ${name}` }
+    }
+
+    // Security: check permission before executing
+    if (this.permission.needsApproval(tool, params)) {
+      return {
+        success: false,
+        content: '',
+        error: `Tool "${name}" requires user approval (permission: ask). The tool was not executed.`,
+      }
+    }
+
+    try {
+      return await tool.execute(params, {
+        cwd: process.cwd(),
+        sessionId: 'session-1',
+        provider: this.registry.getActive().config.id,
+        model: this.registry.getActiveModel(),
+      })
+    } catch (err) {
+      return { success: false, content: '', error: String(err) }
+    }
+  }
+
+  private getToolDefinitions(): Record<string, unknown>[] {
+    return Array.from(this.tools.values()).map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+      input_schema: t.parameters, // Anthropic-style naming
+    }))
+  }
+
+  getContext(): ContextManager {
+    return this.context
+  }
+
+  getTools(): Map<string, ToolDefinition> {
+    return this.tools
+  }
+
+  switchProvider(providerId: string, modelId?: string): void {
+    this.registry.switchProvider(providerId, modelId)
+  }
+}