min-agent 0.1.0

package/src/compaction.ts

@@ -0,0 +1,119 @@
+import { generateText, type ModelMessage, type LanguageModel } from "ai"
+
+/**
+ * Context compaction system.
+ *
+ * When conversation history exceeds a token threshold, older messages are
+ * summarized into a compact form to free up context window space.
+ *
+ * Strategy:
+ * 1. Estimate token count of messages (rough: 1 token ≈ 4 chars for English, 2 chars for CJK)
+ * 2. When over threshold, take older messages and summarize them via the LLM
+ * 3. Replace old messages with a single system summary message
+ * 4. Keep recent N turns verbatim for continuity
+ */
+
+const COMPACTION_PROMPT = `You are a conversation summarizer. Summarize the following conversation history into a concise but complete summary that preserves:
+- Key decisions made
+- Important context and facts discussed
+- Current state of any tasks in progress
+- User preferences mentioned
+- File paths, code snippets, or technical details that are still relevant
+
+Be concise but don't lose critical information. Output only the summary, no preamble.`
+
+// Default: trigger compaction at ~80% of context window
+const DEFAULT_MAX_TOKENS = 128000
+const COMPACTION_RATIO = 0.75
+const KEEP_RECENT_TURNS = 4 // Keep last N user+assistant pairs verbatim
+
+export interface CompactionConfig {
+  maxTokens?: number
+  keepRecentTurns?: number
+}
+
+/** Rough token estimation */
+export function estimateTokens(messages: ModelMessage[]): number {
+  let chars = 0
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      chars += msg.content.length
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if ("text" in part && typeof part.text === "string") {
+          chars += part.text.length
+        }
+      }
+    }
+  }
+  // Rough estimate: mix of English (~4 chars/token) and CJK (~2 chars/token)
+  return Math.ceil(chars / 3)
+}
+
+/** Check if compaction is needed */
+export function needsCompaction(messages: ModelMessage[], config?: CompactionConfig): boolean {
+  const maxTokens = config?.maxTokens ?? DEFAULT_MAX_TOKENS
+  const threshold = maxTokens * COMPACTION_RATIO
+  return estimateTokens(messages) > threshold
+}
+
+/** Compact messages by summarizing older history */
+export async function compactMessages(
+  messages: ModelMessage[],
+  model: LanguageModel,
+  config?: CompactionConfig,
+): Promise<{ messages: ModelMessage[]; compacted: boolean }> {
+  const keepTurns = config?.keepRecentTurns ?? KEEP_RECENT_TURNS
+
+  if (messages.length <= keepTurns * 2) {
+    // Not enough messages to compact
+    return { messages, compacted: false }
+  }
+
+  // Split: older messages to summarize, recent messages to keep
+  const splitIdx = messages.length - keepTurns * 2
+  const toSummarize = messages.slice(0, splitIdx)
+  const toKeep = messages.slice(splitIdx)
+
+  // Build conversation text for summarization
+  const conversationText = toSummarize
+    .map((msg) => {
+      const role = msg.role
+      const content = typeof msg.content === "string"
+        ? msg.content
+        : Array.isArray(msg.content)
+          ? msg.content
+              .filter((p): p is { type: "text"; text: string } => "text" in p)
+              .map((p) => p.text)
+              .join("\n")
+          : ""
+      return `[${role}]: ${content.slice(0, 2000)}`
+    })
+    .join("\n\n")
+
+  try {
+    const result = await generateText({
+      model,
+      messages: [
+        { role: "system", content: COMPACTION_PROMPT },
+        { role: "user", content: `Summarize this conversation:\n\n${conversationText}` },
+      ],
+    })
+
+    const summary = result.text
+
+    // Build compacted message list
+    const compactedMessages: ModelMessage[] = [
+      {
+        role: "system",
+        content: `[Context Summary - Previous conversation was compacted]\n\n${summary}`,
+      },
+      ...toKeep,
+    ]
+
+    return { messages: compactedMessages, compacted: true }
+  } catch {
+    // If summarization fails, just truncate older messages
+    return { messages: toKeep, compacted: true }
+  }
+}

package/src/config.ts

@@ -0,0 +1,172 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs"
+import path from "path"
+import os from "os"
+import readline from "readline"
+
+const CONFIG_DIR = path.join(os.homedir(), ".min-agent")
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json")
+const RULES_FILE = path.join(CONFIG_DIR, "rules.md")
+
+export interface ProviderConfig {
+  type?: "openai-compatible" | "openai" | "ollama"
+  baseURL: string
+  apiKey: string
+  defaultModel?: string
+}
+
+export interface AppConfig {
+  provider?: ProviderConfig
+  instructions?: string[]
+}
+
+export function getConfigDir(): string {
+  return CONFIG_DIR
+}
+
+export function getRulesFile(): string {
+  return RULES_FILE
+}
+
+export function loadConfig(): AppConfig {
+  if (!existsSync(CONFIG_FILE)) return {}
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"))
+  } catch {
+    return {}
+  }
+}
+
+export function saveConfig(config: AppConfig) {
+  mkdirSync(CONFIG_DIR, { recursive: true })
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8")
+}
+
+export function isConfigured(): boolean {
+  const config = loadConfig()
+  return !!(config.provider?.baseURL && config.provider?.apiKey)
+}
+
+async function fetchModelsFromURL(url: string, apiKey: string): Promise<string[]> {
+  const noCacheURL = new URL(url)
+  noCacheURL.searchParams.set("_t", Date.now().toString())
+
+  const response = await fetch(noCacheURL.toString(), {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      Pragma: "no-cache",
+      Expires: "0",
+    },
+    cache: "no-store",
+    signal: AbortSignal.timeout(10000),
+  })
+  if (!response.ok) return []
+  const data = (await response.json()) as any
+  const models = (data.data ?? data ?? []) as Array<{ id: string }>
+  return models.map((m) => m.id).sort()
+}
+
+function ask(rl: readline.Interface, question: string, defaultValue?: string): Promise<string> {
+  const suffix = defaultValue ? ` (${defaultValue})` : ""
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultValue || "")
+    })
+  })
+}
+
+export async function fetchModels(baseURL: string, apiKey: string): Promise<string[]> {
+  try {
+    const trimmed = baseURL.replace(/\/$/, "")
+    const primary = await fetchModelsFromURL(`${trimmed}/models`, apiKey)
+    if (primary.length > 0) return primary
+
+    // Ollama users often provide host without /v1; auto-retry that variant.
+    if (!trimmed.endsWith("/v1")) {
+      return await fetchModelsFromURL(`${trimmed}/v1/models`, apiKey)
+    }
+
+    return []
+  } catch {
+    return []
+  }
+}
+
+export async function runSetup(): Promise<void> {
+  const config = loadConfig()
+  const existing = config.provider
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+
+  console.log("\n🔧 min-agent 配置\n")
+
+  console.log("Provider 类型:")
+  console.log("  1. openai-compatible (默认，兼容 OpenAI API 的任意服务)")
+  console.log("  2. openai (OpenAI 官方)")
+  console.log("  3. ollama (本地 Ollama)")
+  console.log()
+
+  const typeChoice = await ask(rl, "选择 Provider (1/2/3)", existing?.type === "ollama" ? "3" : existing?.type === "openai" ? "2" : "1")
+  const providerType = typeChoice === "3" ? "ollama" as const
+    : typeChoice === "2" ? "openai" as const
+    : "openai-compatible" as const
+
+  let baseURL: string
+  let apiKey: string
+
+  if (providerType === "ollama") {
+    baseURL = await ask(rl, "Ollama API URL", existing?.baseURL || "http://localhost:11434/v1")
+    if (!baseURL.replace(/\/$/, "").endsWith("/v1")) {
+      baseURL = `${baseURL.replace(/\/$/, "")}/v1`
+    }
+    apiKey = "ollama" // Ollama doesn't need a real key
+  } else if (providerType === "openai") {
+    baseURL = "https://api.openai.com/v1"
+    apiKey = await ask(rl, "OpenAI API Key", existing?.apiKey)
+  } else {
+    baseURL = await ask(rl, "API Base URL", existing?.baseURL || "https://api.openai.com/v1")
+    apiKey = await ask(rl, "API Key", existing?.apiKey)
+  }
+
+  if (!baseURL || (!apiKey && providerType !== "ollama")) {
+    console.error("URL 和 Key 不能为空")
+    rl.close()
+    process.exit(1)
+  }
+
+  console.log("\n正在获取模型列表...")
+  const models = await fetchModels(baseURL, apiKey)
+
+  let defaultModel = existing?.defaultModel ?? ""
+
+  if (models.length > 0) {
+    console.log(`\n可用模型 (${models.length}):`)
+    models.forEach((m, i) => {
+      const marker = m === defaultModel ? " ← 当前默认" : ""
+      console.log(`  ${i + 1}. ${m}${marker}`)
+    })
+    console.log()
+
+    const choice = await ask(rl, "选择默认模型 (输入序号或模型名)", defaultModel)
+    const idx = parseInt(choice) - 1
+    if (idx >= 0 && idx < models.length) {
+      defaultModel = models[idx]
+    } else if (choice) {
+      defaultModel = choice
+    }
+  } else {
+    console.log("  ⚠ 无法获取模型列表，请手动输入模型名")
+    const hint = providerType === "ollama" ? "llama3" : providerType === "openai" ? "gpt-4o" : ""
+    defaultModel = await ask(rl, "默认模型", defaultModel || hint)
+  }
+
+  rl.close()
+
+  config.provider = { type: providerType, baseURL, apiKey, defaultModel }
+  saveConfig(config)
+
+  console.log(`\n✓ 配置已保存到 ${CONFIG_FILE}`)
+  console.log(`  Type:  ${providerType}`)
+  console.log(`  URL:   ${baseURL}`)
+  console.log(`  Model: ${defaultModel}\n`)
+}

package/src/confirm.ts

@@ -0,0 +1,42 @@
+import readline from "readline"
+
+let autoApprove = false
+
+export function setAutoApprove(value: boolean) {
+  autoApprove = value
+}
+
+export function isAutoApprove(): boolean {
+  return autoApprove
+}
+
+/** Ask user for confirmation. Returns true if approved. */
+export async function confirm(message: string): Promise<boolean> {
+  if (autoApprove) return true
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) => {
+    rl.question(`\x1b[33m⚠ ${message} [y/N] \x1b[0m`, (answer) => {
+      rl.close()
+      resolve(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes")
+    })
+  })
+}
+
+/** Check if a shell command is potentially dangerous */
+export function isDangerousCommand(command: string): boolean {
+  const dangerous = [
+    /\brm\s+(-rf?|--recursive)\s/,
+    /\brm\s+-[a-z]*f/,
+    /\bsudo\b/,
+    /\bmkfs\b/,
+    /\bdd\s+/,
+    /\b(shutdown|reboot|halt|poweroff)\b/,
+    /\bgit\s+(push|reset\s+--hard|clean\s+-[a-z]*f)/,
+    /\bnpm\s+publish\b/,
+    /\bdrop\s+(table|database)\b/i,
+    /\btruncate\s+table\b/i,
+    /\bformat\b.*\b[a-z]:\b/i,
+  ]
+  return dangerous.some((re) => re.test(command))
+}

package/src/instructions.ts

@@ -0,0 +1,123 @@
+import { readFileSync, existsSync } from "fs"
+import path from "path"
+import os from "os"
+import { getConfigDir, getRulesFile, loadConfig } from "./config.js"
+
+/**
+ * Instruction/rules system.
+ *
+ * All config lives under ~/.min-agent/:
+ *   ~/.min-agent/rules.md          — Global rules (always loaded)
+ *   ~/.min-agent/config.json       — Can specify extra "instructions" paths/URLs
+ *
+ * Project-level rules (auto-discovered from cwd):
+ *   ./AGENTS.md, ./RULES.md, ./.min-agent/AGENTS.md
+ */
+
+const PROJECT_FILES = ["AGENTS.md", "RULES.md", "CLAUDE.md"]
+
+function findProjectInstructions(): string[] {
+  const results: string[] = []
+  let current = process.cwd()
+  const root = path.parse(current).root
+
+  while (current !== root) {
+    // Check .min-agent/AGENTS.md in project
+    const dotDir = path.join(current, ".min-agent", "AGENTS.md")
+    if (existsSync(dotDir)) {
+      results.push(dotDir)
+      break
+    }
+
+    for (const file of PROJECT_FILES) {
+      const filepath = path.join(current, file)
+      if (existsSync(filepath)) {
+        results.push(filepath)
+        break
+      }
+    }
+
+    if (results.length > 0) break
+    current = path.dirname(current)
+  }
+
+  return results
+}
+
+function findGlobalRules(): string[] {
+  const results: string[] = []
+  const rulesFile = getRulesFile()
+  if (existsSync(rulesFile)) results.push(rulesFile)
+  return results
+}
+
+function resolveConfigInstructions(): string[] {
+  const config = loadConfig()
+  const instructions = config.instructions ?? []
+  const results: string[] = []
+
+  for (const item of instructions) {
+    if (item.startsWith("http://") || item.startsWith("https://")) continue
+    const resolved = item.startsWith("~/")
+      ? path.join(os.homedir(), item.slice(2))
+      : path.isAbsolute(item)
+        ? item
+        : path.resolve(process.cwd(), item)
+    if (existsSync(resolved)) results.push(resolved)
+  }
+
+  return results
+}
+
+async function fetchRemoteInstructions(): Promise<string[]> {
+  const config = loadConfig()
+  const instructions = config.instructions ?? []
+  const results: string[] = []
+
+  const urls = instructions.filter((i) => i.startsWith("http://") || i.startsWith("https://"))
+  for (const url of urls) {
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(5000) })
+      if (response.ok) {
+        const text = await response.text()
+        if (text.trim()) results.push(`Instructions from: ${url}\n${text}`)
+      }
+    } catch {}
+  }
+
+  return results
+}
+
+export async function loadInstructions(): Promise<string[]> {
+  const parts: string[] = []
+
+  // Global rules from ~/.min-agent/rules.md
+  for (const filepath of findGlobalRules()) {
+    try {
+      const content = readFileSync(filepath, "utf-8").trim()
+      if (content) parts.push(`Instructions from: ${filepath}\n${content}`)
+    } catch {}
+  }
+
+  // Project-level instructions
+  for (const filepath of findProjectInstructions()) {
+    try {
+      const content = readFileSync(filepath, "utf-8").trim()
+      if (content) parts.push(`Instructions from: ${filepath}\n${content}`)
+    } catch {}
+  }
+
+  // Config-defined file instructions
+  for (const filepath of resolveConfigInstructions()) {
+    try {
+      const content = readFileSync(filepath, "utf-8").trim()
+      if (content) parts.push(`Instructions from: ${filepath}\n${content}`)
+    } catch {}
+  }
+
+  // Remote URL instructions
+  const remote = await fetchRemoteInstructions()
+  parts.push(...remote)
+
+  return parts
+}

package/src/markdown.ts

@@ -0,0 +1,140 @@
+/**
+ * Lightweight streaming markdown renderer for terminal.
+ * Tracks state across text deltas to apply ANSI formatting.
+ */
+
+function useColor(): boolean {
+  if ("NO_COLOR" in process.env) return false
+  if (process.env.FORCE_COLOR === "0") return false
+  return true
+}
+
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  italic: "\x1b[3m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  magenta: "\x1b[35m",
+  gray: "\x1b[90m",
+  underline: "\x1b[4m",
+}
+
+const Z = {
+  reset: "",
+  bold: "",
+  dim: "",
+  italic: "",
+  cyan: "",
+  green: "",
+  yellow: "",
+  magenta: "",
+  gray: "",
+  underline: "",
+}
+
+export class MarkdownRenderer {
+  private buffer = ""
+  private inCodeBlock = false
+  private codeLang = ""
+
+  /** Process a text delta and return formatted output */
+  write(text: string): string {
+    this.buffer += text
+    let output = ""
+    const c = useColor() ? C : Z
+
+    // Process complete lines
+    while (true) {
+      const nlIdx = this.buffer.indexOf("\n")
+      if (nlIdx === -1) break
+
+      const line = this.buffer.slice(0, nlIdx)
+      this.buffer = this.buffer.slice(nlIdx + 1)
+      output += this.formatLine(line, c) + "\n"
+    }
+
+    return output
+  }
+
+  /** Flush remaining buffer */
+  flush(): string {
+    if (!this.buffer) return ""
+    const c = useColor() ? C : Z
+    const out = this.formatLine(this.buffer, c)
+    this.buffer = ""
+    return out
+  }
+
+  private formatInline(line: string, c: typeof C): string {
+    // Split by inline code spans; format outside segments only
+    const parts = line.split(/(`[^`]*`)/g)
+    return parts
+      .map((seg) => {
+        if (seg.startsWith("`") && seg.endsWith("`") && seg.length >= 2) {
+          const inner = seg.slice(1, -1)
+          return `${c.cyan}${inner}${c.reset}`
+        }
+        let s = seg
+        s = s.replace(/\*\*([^*]+)\*\*/g, `${c.bold}$1${c.reset}`)
+        s = s.replace(/\*([^*]+)\*/g, `${c.italic}$1${c.reset}`)
+        s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, `${c.cyan}$1${c.reset} ${c.dim}($2)${c.reset}`)
+        return s
+      })
+      .join("")
+  }
+
+  private formatLine(line: string, c: typeof C): string {
+    // Code block fence
+    if (line.startsWith("```")) {
+      if (!this.inCodeBlock) {
+        this.inCodeBlock = true
+        this.codeLang = line.slice(3).trim()
+        return `${c.dim}┌─ ${this.codeLang || "code"} ${"─".repeat(Math.max(0, 40 - (this.codeLang?.length ?? 0)))}${c.reset}`
+      }
+      this.inCodeBlock = false
+      this.codeLang = ""
+      return `${c.dim}└${"─".repeat(44)}${c.reset}`
+    }
+
+    // Inside code block — dim
+    if (this.inCodeBlock) {
+      return `${c.dim}│${c.reset} ${line}`
+    }
+
+    // Headers
+    if (line.startsWith("### ")) return `${c.bold}${this.formatInline(line.slice(4), c)}${c.reset}`
+    if (line.startsWith("## ")) return `${c.bold}${this.formatInline(line.slice(3), c)}${c.reset}`
+    if (line.startsWith("# ")) return `${c.bold}${c.cyan}${this.formatInline(line.slice(2), c)}${c.reset}`
+
+    // Horizontal rule
+    if (/^---+$/.test(line)) return `${c.dim}${"─".repeat(44)}${c.reset}`
+
+    // Blockquote
+    const bq = line.match(/^(\s*)>\s?(.*)$/)
+    if (bq) {
+      const indent = bq[1]
+      const body = bq[2]
+      return `${indent}${c.dim}▎${c.reset} ${this.formatInline(body, c)}`
+    }
+
+    // Numbered list (1. item)
+    if (/^\s*\d+\.\s/.test(line)) {
+      const m = line.match(/^(\s*)(\d+\.)(\s)(.*)$/)
+      if (m) {
+        return `${m[1]}${c.yellow}${m[2]}${c.reset}${m[3]}${this.formatInline(m[4], c)}`
+      }
+    }
+
+    // Bullet points
+    if (line.match(/^\s*[-*]\s/)) {
+      return line.replace(/^(\s*)([-*])(\s)(.*)$/, (_a, sp, _mark, sp2, rest) => {
+        return `${sp}${c.cyan}•${c.reset}${sp2}${this.formatInline(rest, c)}`
+      })
+    }
+
+    return this.formatInline(line, c)
+  }
+}