@kkelly-offical/kkcode 0.1.3 → 0.1.7

package/src/session/system-prompt.mjs

@@ -1,260 +1,273 @@
-import { readFile, access } from "node:fs/promises"
-import { execSync } from "node:child_process"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-import { createHash } from "node:crypto"
-import { loadSessionPrompt } from "./prompt-loader.mjs"
-import { getAgentPrompt, listAgents } from "../agent/agent.mjs"
-import { loadAutoMemory } from "./memory-loader.mjs"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const TOOL_PROMPT_DIR = path.join(__dirname, "..", "tool", "prompt")
-
-const toolPromptCache = new Map()
-
-// Session-level block cache: avoids rebuilding identical blocks across turns
-// Key = hash of inputs, Value = { blocks, text, timestamp }
-let blockCache = { key: null, result: null }
-
-function hashInputs(obj) {
-  return createHash("md5").update(JSON.stringify(obj)).digest("hex")
-}
-
-async function loadToolPrompt(name) {
-  if (!toolPromptCache.has(name)) {
-    try {
-      const file = path.join(TOOL_PROMPT_DIR, `${name}.txt`)
-      const text = (await readFile(file, "utf8")).trim()
-      toolPromptCache.set(name, text)
-    } catch {
-      toolPromptCache.set(name, "")
-    }
-  }
-  return toolPromptCache.get(name)
-}
-
-// Detect if cwd is a git repo
-function detectGitRepo(cwd) {
-  try {
-    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe", timeout: 3000 })
-    return true
-  } catch {
-    return false
-  }
-}
-
-// Detect the user's default shell
-function detectShell() {
-  if (process.platform === "win32") {
-    // On Windows, kkcode uses bash (git bash / WSL) internally
-    return "bash (use Unix shell syntax, not Windows — e.g., /dev/null not NUL, forward slashes in paths)"
-  }
-  const shell = process.env.SHELL || "/bin/bash"
-  return path.basename(shell)
-}
-
-// Layer 1: Environment information (dynamic per turn — changes with cwd/date)
-export function environmentPrompt({ model, cwd }) {
-  const isGit = detectGitRepo(cwd)
-  const shell = detectShell()
-  const today = new Date().toISOString().slice(0, 10)
-  const lines = [
-    `<env>`,
-    `  model: ${model}`,
-    `  cwd: ${cwd}`,
-    `  platform: ${process.platform}`,
-    `  shell: ${shell}`,
-    `  node: ${process.version}`,
-    `  date: ${today}`,
-    `  git_repo: ${isGit}`,
-    `</env>`,
-    ``,
-    `Knowledge cutoff: early 2025. Current date: ${today}.`,
-    `When searching for recent information, use the current year (${today.slice(0, 4)}) in queries.`
-  ]
-  return lines.join("\n")
-}
-
-// Layer 2: System prompt (model-specific — stable across session)
-export async function providerPromptByModel(model) {
-  const m = String(model).toLowerCase()
-  if (m.includes("claude")) return loadSessionPrompt("anthropic.txt")
-  if (m.includes("gpt-5") || m.includes("codex")) return loadSessionPrompt("beast.txt")
-  if (m.includes("gpt") || m.includes("o1") || m.includes("o3")) return loadSessionPrompt("beast.txt")
-  if (m.includes("gemini")) return loadSessionPrompt("qwen.txt")
-  if (m.includes("deepseek")) return loadSessionPrompt("qwen.txt")
-  if (m.includes("qwen")) return loadSessionPrompt("qwen.txt")
-  return loadSessionPrompt("qwen.txt")
-}
-
-// Layer 3: Agent-specific prompt (stable across session)
-export async function agentPrompt(agent) {
-  if (!agent) return ""
-  return getAgentPrompt(agent.name)
-}
-
-// Layer 4: Mode reminder (stable within mode)
-export async function modeReminder(mode) {
-  if (mode === "plan") return loadSessionPrompt("plan.txt")
-  return ""
-}
-
-// Layer 5: Tool descriptions (stable across session — ideal cache target)
-export async function toolDescriptions(tools) {
-  if (!tools || !tools.length) return ""
-  const descriptions = []
-  for (const tool of tools) {
-    const prompt = await loadToolPrompt(tool.name)
-    if (prompt) {
-      descriptions.push(`## ${tool.name}\n${prompt}`)
-    }
-  }
-  if (!descriptions.length) return ""
-  return `# Available Tools\n\n${descriptions.join("\n\n")}`
-}
-
-// Layer 6: User custom instructions (loaded externally via instruction-loader.mjs and rules)
-// Assembled in loop.mjs from loadInstructions() and renderRulesPrompt()
-
-/**
- * Build system prompt as structured blocks for provider-level cache optimization.
- *
- * Returns { text, blocks } where:
- * - text: single concatenated string (for providers that don't support block-level caching)
- * - blocks: array of { label, text, cacheable } objects
- *
- * Cache strategy:
- * - Blocks marked cacheable=true are stable across turns (provider/agent/tools/skills)
- * - Blocks marked cacheable=false are dynamic per turn (env/user instructions)
- * - Providers use this to place cache_control breakpoints optimally
- *
- * Anthropic: up to 4 cache breakpoints — place on stable blocks
- * OpenAI: automatic prefix caching — stable blocks should come first
- */
-export async function buildSystemPromptBlocks({ mode, model, cwd, agent = null, tools = [], skills = [], userInstructions = "", projectContext = "", language = "en" }) {
-  // Cache key: hash of all inputs that affect block content
-  const cacheKey = hashInputs({
-    mode, model, cwd, language,
-    agent: agent?.name || null,
-    tools: tools.map(t => t.name).sort(),
-    skills: skills.map(s => s.name).sort(),
-    userInstructions: userInstructions.slice(0, 200) // first 200 chars as fingerprint
-  })
-
-  if (blockCache.key === cacheKey && blockCache.result) {
-    // Only env block changes per turn — rebuild just that
-    const cached = blockCache.result
-    const envIdx = cached.blocks.findIndex(b => b.label === "env")
-    if (envIdx >= 0) {
-      const freshEnv = environmentPrompt({ model, cwd })
-      if (cached.blocks[envIdx].text === freshEnv) {
-        return cached // fully identical
-      }
-      // Clone and update only the env block
-      const updatedBlocks = cached.blocks.map((b, i) =>
-        i === envIdx ? { ...b, text: freshEnv } : b
-      )
-      const text = updatedBlocks.map(b => b.text).join("\n\n")
-      const result = { text, blocks: updatedBlocks }
-      blockCache = { key: cacheKey, result }
-      return result
-    }
-  }
-
-  const blocks = []
-
-  // Block 0: Provider prompt (stable — loaded once per model)
-  const providerText = await providerPromptByModel(model)
-  if (providerText) {
-    blocks.push({ label: "provider", text: providerText, cacheable: true })
-  }
-
-  // Block 1: Agent prompt (stable — loaded once per agent)
-  const agentText = agent ? await getAgentPrompt(agent.name) : ""
-  if (agentText) {
-    blocks.push({ label: "agent", text: agentText, cacheable: true })
-  }
-
-  // Block 2: Mode reminder (stable within mode)
-  const modeText = await modeReminder(mode)
-  if (modeText) {
-    blocks.push({ label: "mode", text: modeText, cacheable: true })
-  }
-
-  // Block 3: Tool descriptions (stable — changes only when tools change)
-  const toolText = await toolDescriptions(tools)
-  if (toolText) {
-    blocks.push({ label: "tools", text: toolText, cacheable: true })
-  }
-
-  // Block 4: Skills descriptions (stable — changes only when skills change)
-  if (skills.length) {
-    const skillLines = skills.map((s) => `- /${s.name}: ${s.description || s.name}`).join("\n")
-    const skillText = `# Available Skills\n\nInvoke with /<skill-name> [arguments].\n\n${skillLines}`
-    blocks.push({ label: "skills", text: skillText, cacheable: true })
-  }
-
-  // Block 4.5: Available sub-agents (stable — changes only when custom agents change)
-  const allAgents = listAgents({ includeHidden: false })
-  const customSubagents = allAgents.filter((a) => a.mode === "subagent" && a._customAgent)
-  if (customSubagents.length) {
-    const agentLines = customSubagents.map((a) => {
-      const perms = a.permission === "readonly" ? " (read-only)" : a.permission === "full" ? " (full access)" : ""
-      return `- ${a.name}: ${a.description}${perms}`
-    })
-    const subagentText = [
-      "# Available Sub-agents",
-      "",
-      "Delegate specialized work to these sub-agents using the `task` tool with `subagent_type` parameter.",
-      "Use sub-agents when a task is self-contained and would benefit from a specialist, or to save context window space.",
-      "",
-      ...agentLines
-    ].join("\n")
-    blocks.push({ label: "subagents", text: subagentText, cacheable: true })
-  }
-
-  // Block 4.7: Project context (semi-stable — changes when cwd changes)
-  if (projectContext) {
-    blocks.push({ label: "project", text: projectContext, cacheable: false })
-  }
-
-  // Block 4.9: Language constraint (stable — changes only when config changes)
-  if (language && language !== "en") {
-    const langMap = {
-      zh: "Always respond in Chinese (中文). Use Chinese for all explanations, comments, and communications. Technical terms, code identifiers, and code content should remain in their original form (typically English)."
-    }
-    const langText = langMap[language]
-    if (langText) {
-      blocks.push({ label: "language", text: `# Language\n\n${langText}`, cacheable: true })
-    }
-  }
-
-  // Block 4.95: Auto Memory (semi-stable — changes when user updates memory files)
-  const memoryText = await loadAutoMemory(cwd)
-  if (memoryText) {
-    blocks.push({ label: "memory", text: memoryText, cacheable: false })
-  }
-
-  // Block 5: Environment (dynamic per turn)
-  const envText = environmentPrompt({ model, cwd })
-  blocks.push({ label: "env", text: envText, cacheable: false })
-
-  // Block 6: User instructions + rules (semi-stable — cacheable if unchanged between turns)
-  if (userInstructions) {
-    blocks.push({ label: "user", text: userInstructions, cacheable: false })
-  }
-
-  const text = blocks.map((b) => b.text).join("\n\n")
-  const result = { text, blocks }
-  blockCache = { key: cacheKey, result }
-  return result
-}
-
-// Legacy flat assembly (kept for backward compatibility)
-export async function buildSystemPromptLayers({ mode, model, cwd, agent = null }) {
-  const layer1 = environmentPrompt({ model, cwd })
-  const layer2 = await providerPromptByModel(model)
-  const layer3 = await agentPrompt(agent)
-  const layer4 = await modeReminder(mode)
-  return { layer1, layer2, layer3, layer4 }
-}
+import { readFile, access } from "node:fs/promises"
+import { execSync } from "node:child_process"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { createHash } from "node:crypto"
+import { loadSessionPrompt } from "./prompt-loader.mjs"
+import { getAgentPrompt, listAgents } from "../agent/agent.mjs"
+import { loadAutoMemory } from "./memory-loader.mjs"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const TOOL_PROMPT_DIR = path.join(__dirname, "..", "tool", "prompt")
+
+const toolPromptCache = new Map()
+
+// Session-level block cache: avoids rebuilding identical blocks across turns
+// Key = hash of inputs, Value = { blocks, text, timestamp }
+let blockCache = { key: null, result: null }
+
+function hashInputs(obj) {
+  return createHash("md5").update(JSON.stringify(obj)).digest("hex")
+}
+
+async function loadToolPrompt(name) {
+  if (!toolPromptCache.has(name)) {
+    try {
+      const file = path.join(TOOL_PROMPT_DIR, `${name}.txt`)
+      const text = (await readFile(file, "utf8")).trim()
+      toolPromptCache.set(name, text)
+    } catch {
+      toolPromptCache.set(name, "")
+    }
+  }
+  return toolPromptCache.get(name)
+}
+
+// Detect if cwd is a git repo
+function detectGitRepo(cwd) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe", timeout: 3000 })
+    return true
+  } catch {
+    return false
+  }
+}
+
+// Detect the user's default shell
+function detectShell() {
+  if (process.platform === "win32") {
+    // On Windows, kkcode uses bash (git bash / WSL) internally
+    return "bash (use Unix shell syntax, not Windows — e.g., /dev/null not NUL, forward slashes in paths)"
+  }
+  const shell = process.env.SHELL || "/bin/bash"
+  return path.basename(shell)
+}
+
+// Layer 1: Environment information (dynamic per turn — changes with cwd/date)
+export function environmentPrompt({ model, cwd }) {
+  const isGit = detectGitRepo(cwd)
+  const shell = detectShell()
+  const today = new Date().toISOString().slice(0, 10)
+  const lines = [
+    `<env>`,
+    `  model: ${model}`,
+    `  cwd: ${cwd}`,
+    `  platform: ${process.platform}`,
+    `  shell: ${shell}`,
+    `  node: ${process.version}`,
+    `  date: ${today}`,
+    `  git_repo: ${isGit}`,
+    `</env>`,
+    ``,
+    `Knowledge cutoff: early 2025. Current date: ${today}.`,
+    `When searching for recent information, use the current year (${today.slice(0, 4)}) in queries.`
+  ]
+  return lines.join("\n")
+}
+
+// Layer 2: System prompt (model-specific — stable across session)
+export async function providerPromptByModel(model) {
+  const m = String(model).toLowerCase()
+  if (m.includes("claude")) return loadSessionPrompt("anthropic.txt")
+  if (m.includes("gpt-5") || m.includes("codex")) return loadSessionPrompt("beast.txt")
+  if (m.includes("gpt") || m.includes("o1") || m.includes("o3")) return loadSessionPrompt("beast.txt")
+  if (m.includes("gemini")) return loadSessionPrompt("qwen.txt")
+  if (m.includes("deepseek")) return loadSessionPrompt("qwen.txt")
+  if (m.includes("qwen")) return loadSessionPrompt("qwen.txt")
+  return loadSessionPrompt("qwen.txt")
+}
+
+// Layer 3: Agent-specific prompt (stable across session)
+export async function agentPrompt(agent) {
+  if (!agent) return ""
+  return getAgentPrompt(agent.name)
+}
+
+// Layer 4: Mode reminder (stable within mode)
+export async function modeReminder(mode) {
+  if (mode === "plan") return loadSessionPrompt("plan.txt")
+  if (mode === "agent") return loadSessionPrompt("agent.txt")
+  return ""
+}
+
+// Layer 5: Tool descriptions (stable across session — ideal cache target)
+export async function toolDescriptions(tools) {
+  if (!tools || !tools.length) return ""
+  const descriptions = []
+  for (const tool of tools) {
+    const prompt = await loadToolPrompt(tool.name)
+    if (prompt) {
+      descriptions.push(`## ${tool.name}\n${prompt}`)
+    }
+  }
+  if (!descriptions.length) return ""
+  return `# Available Tools\n\n${descriptions.join("\n\n")}`
+}
+
+// Layer 6: User custom instructions (loaded externally via instruction-loader.mjs and rules)
+// Assembled in loop.mjs from loadInstructions() and renderRulesPrompt()
+
+/**
+ * Build system prompt as structured blocks for provider-level cache optimization.
+ *
+ * Returns { text, blocks } where:
+ * - text: single concatenated string (for providers that don't support block-level caching)
+ * - blocks: array of { label, text, cacheable } objects
+ *
+ * Cache strategy:
+ * - Blocks marked cacheable=true are stable across turns (provider/agent/tools/skills)
+ * - Blocks marked cacheable=false are dynamic per turn (env/user instructions)
+ * - Providers use this to place cache_control breakpoints optimally
+ *
+ * Anthropic: up to 4 cache breakpoints — place on stable blocks
+ * OpenAI: automatic prefix caching — stable blocks should come first
+ */
+export async function buildSystemPromptBlocks({ mode, model, cwd, agent = null, tools = [], skills = [], userInstructions = "", projectContext = "", language = "en" }) {
+  // Cache key: hash of all inputs that affect block content
+  const cacheKey = hashInputs({
+    mode, model, cwd, language,
+    agent: agent?.name || null,
+    tools: tools.map(t => t.name).sort(),
+    skills: skills.map(s => s.name).sort(),
+    userInstructions: userInstructions.slice(0, 200) // first 200 chars as fingerprint
+  })
+
+  if (blockCache.key === cacheKey && blockCache.result) {
+    // Only env block changes per turn — rebuild just that
+    const cached = blockCache.result
+    const envIdx = cached.blocks.findIndex(b => b.label === "env")
+    if (envIdx >= 0) {
+      const freshEnv = environmentPrompt({ model, cwd })
+      if (cached.blocks[envIdx].text === freshEnv) {
+        return cached // fully identical
+      }
+      // Clone and update only the env block
+      const updatedBlocks = cached.blocks.map((b, i) =>
+        i === envIdx ? { ...b, text: freshEnv } : b
+      )
+      const text = updatedBlocks.map(b => b.text).join("\n\n")
+      const result = { text, blocks: updatedBlocks }
+      blockCache = { key: cacheKey, result }
+      return result
+    }
+  }
+
+  const blocks = []
+
+  // Block 0: Provider prompt (stable — loaded once per model)
+  const providerText = await providerPromptByModel(model)
+  if (providerText) {
+    blocks.push({ label: "provider", text: providerText, cacheable: true })
+  }
+
+  // Block 1: Agent prompt (stable — loaded once per agent)
+  const agentText = agent ? await getAgentPrompt(agent.name) : ""
+  if (agentText) {
+    blocks.push({ label: "agent", text: agentText, cacheable: true })
+  }
+
+  // Block 2: Mode reminder (stable within mode)
+  const modeText = await modeReminder(mode)
+  if (modeText) {
+    blocks.push({ label: "mode", text: modeText, cacheable: true })
+  }
+
+  // Block 3: Tool descriptions (stable — changes only when tools change)
+  const toolText = await toolDescriptions(tools)
+  if (toolText) {
+    blocks.push({ label: "tools", text: toolText, cacheable: true })
+  }
+
+  // Block 3.5: Large output strategy (stable — always included)
+  const outputStrategyLines = [
+    "# Large Output Strategy",
+    "",
+    "When generating large amounts of content:",
+    "- For large file creation, write no more than 200 lines per tool call; use append mode for subsequent chunks",
+    "- For partial file edits, use patch with line ranges instead of rewriting the whole file",
+    "- If a task requires more than 300 lines of code, proactively split into multiple sequential tool calls",
+    "- Never attempt to write an entire large file in a single tool call"
+  ]
+  blocks.push({ label: "output_strategy", text: outputStrategyLines.join("\n"), cacheable: true })
+
+  // Block 4: Skills descriptions (stable — changes only when skills change)
+  if (skills.length) {
+    const skillLines = skills.map((s) => `- /${s.name}: ${s.description || s.name}`).join("\n")
+    const skillText = `# Available Skills\n\nInvoke with /<skill-name> [arguments].\n\n${skillLines}`
+    blocks.push({ label: "skills", text: skillText, cacheable: true })
+  }
+
+  // Block 4.5: Available sub-agents (stable — changes only when custom agents change)
+  const allAgents = listAgents({ includeHidden: false })
+  const customSubagents = allAgents.filter((a) => a.mode === "subagent" && a._customAgent)
+  if (customSubagents.length) {
+    const agentLines = customSubagents.map((a) => {
+      const perms = a.permission === "readonly" ? " (read-only)" : a.permission === "full" ? " (full access)" : ""
+      return `- ${a.name}: ${a.description}${perms}`
+    })
+    const subagentText = [
+      "# Available Sub-agents",
+      "",
+      "Delegate specialized work to these sub-agents using the `task` tool with `subagent_type` parameter.",
+      "Use sub-agents when a task is self-contained and would benefit from a specialist, or to save context window space.",
+      "",
+      ...agentLines
+    ].join("\n")
+    blocks.push({ label: "subagents", text: subagentText, cacheable: true })
+  }
+
+  // Block 4.7: Project context (semi-stable — changes when cwd changes)
+  if (projectContext) {
+    blocks.push({ label: "project", text: projectContext, cacheable: false })
+  }
+
+  // Block 4.9: Language constraint (stable — changes only when config changes)
+  if (language && language !== "en") {
+    const langMap = {
+      zh: "Always respond in Chinese (中文). Use Chinese for all explanations, comments, and communications. Technical terms, code identifiers, and code content should remain in their original form (typically English)."
+    }
+    const langText = langMap[language]
+    if (langText) {
+      blocks.push({ label: "language", text: `# Language\n\n${langText}`, cacheable: true })
+    }
+  }
+
+  // Block 4.95: Auto Memory (semi-stable — changes when user updates memory files)
+  const memoryText = await loadAutoMemory(cwd)
+  if (memoryText) {
+    blocks.push({ label: "memory", text: memoryText, cacheable: false })
+  }
+
+  // Block 5: Environment (dynamic per turn)
+  const envText = environmentPrompt({ model, cwd })
+  blocks.push({ label: "env", text: envText, cacheable: false })
+
+  // Block 6: User instructions + rules (semi-stable — cacheable if unchanged between turns)
+  if (userInstructions) {
+    blocks.push({ label: "user", text: userInstructions, cacheable: false })
+  }
+
+  const text = blocks.map((b) => b.text).join("\n\n")
+  const result = { text, blocks }
+  blockCache = { key: cacheKey, result }
+  return result
+}
+
+// Legacy flat assembly (kept for backward compatibility)
+export async function buildSystemPromptLayers({ mode, model, cwd, agent = null }) {
+  const layer1 = environmentPrompt({ model, cwd })
+  const layer2 = await providerPromptByModel(model)
+  const layer3 = await agentPrompt(agent)
+  const layer4 = await modeReminder(mode)
+  return { layer1, layer2, layer3, layer4 }
+}

package/src/session/task-validator.mjs

@@ -1,9 +1,10 @@
-import { exec as execCb } from "node:child_process"
+import { exec as execCb, execFile as execFileCb } from "node:child_process"
 import { promisify } from "node:util"
 import { access, readFile } from "node:fs/promises"
 import path from "node:path"
 
 const exec = promisify(execCb)
+const execFile = promisify(execFileCb)
 
 async function fileExists(p) {
   try { await access(p); return true } catch { return false }
@@ -50,7 +51,7 @@ export class TaskValidator {
     const errors = []
     for (const file of jsFiles.slice(0, 20)) {
       try {
-        await exec(`node --check "${file}"`, { cwd: this.cwd, timeout: 10000 })
+        await execFile("node", ["--check", file], { cwd: this.cwd, timeout: 10000 })
       } catch (error) {
         errors.push(`${file}: ${(error.stderr || error.message || "").trim()}`)
       }
@@ -101,7 +102,7 @@ export class TaskValidator {
     const errors = []
     for (const file of pyFiles.slice(0, 20)) {
       try {
-        await exec(`python -m py_compile "${file}"`, { cwd: this.cwd, timeout: 10000 })
+        await execFile("python", ["-m", "py_compile", file], { cwd: this.cwd, timeout: 10000 })
       } catch (error) {
         errors.push(`${file}: ${(error.stderr || error.message || "").trim()}`)
       }

package/src/skill/builtin/design.mjs

@@ -0,0 +1,76 @@
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+
+export const name = "design"
+export const description = "Frontend design mode — generates polished, distinctive UI with strong aesthetics (usage: /design <task>)"
+
+async function detectDesignContext(cwd) {
+  try {
+    const pkg = JSON.parse(await readFile(path.join(cwd, "package.json"), "utf8"))
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+    const ctx = {}
+    // Framework
+    if (deps.next) ctx.framework = "next"
+    else if (deps.nuxt) ctx.framework = "nuxt"
+    else if (deps.vue) ctx.framework = "vue"
+    else if (deps.react) ctx.framework = "react"
+    else if (deps.svelte || deps["@sveltejs/kit"]) ctx.framework = "svelte"
+    // CSS
+    if (deps.tailwindcss) ctx.css = "tailwind"
+    else if (deps.unocss) ctx.css = "unocss"
+    else if (deps["styled-components"]) ctx.css = "styled-components"
+    // Component lib
+    if (deps.antd) ctx.lib = "antd"
+    else if (deps["element-plus"]) ctx.lib = "element-plus"
+    else if (deps["@mui/material"]) ctx.lib = "mui"
+    else if (deps["@chakra-ui/react"]) ctx.lib = "chakra-ui"
+    else if (deps["@mantine/core"]) ctx.lib = "mantine"
+    else if (deps["naive-ui"]) ctx.lib = "naive-ui"
+    return ctx
+  } catch { return {} }
+}
+
+const AESTHETICS_PROMPT = `<frontend_aesthetics>
+You are in DESIGN MODE. Create polished, distinctive frontends — NOT generic AI output.
+
+Typography: Avoid Inter/Roboto/Arial. Use distinctive fonts (Space Grotesk, Playfair Display, Satoshi, IBM Plex). Extreme weight contrast (200 vs 800), 3x+ size jumps.
+
+Color: CSS variables for ALL colors. Dominant color + sharp accent. Draw from IDE themes (Nord, Catppuccin), cultural aesthetics. AVOID purple-gradient-on-white.
+
+Motion: One high-impact staggered reveal per page. Micro-interactions on hover/focus/press. CSS transitions + animation-delay.
+
+Layout: CSS Grid for pages, Flexbox for components. Generous whitespace. Consistent 4px spacing scale. Mobile-first.
+
+Depth: Layered gradients, backdrop-filter glass, box-shadow elevation hierarchy.
+
+NEVER: cookie-cutter card grids, generic hero sections, border-radius:9999px everywhere, gray wireframe text, no visual rhythm.
+</frontend_aesthetics>`
+
+export async function run(ctx) {
+  const task = (ctx.args || "").trim()
+  const cwd = ctx.cwd || process.cwd()
+  const design = await detectDesignContext(cwd)
+
+  const parts = [AESTHETICS_PROMPT, ""]
+
+  if (Object.keys(design).length) {
+    parts.push("## Project Design Context")
+    if (design.framework) parts.push(`- Framework: ${design.framework}`)
+    if (design.css) parts.push(`- CSS: ${design.css}`)
+    if (design.lib) parts.push(`- Component Library: ${design.lib}`)
+    parts.push("")
+    parts.push("Read the project's existing styles/theme before writing new code. Extend, don't replace.")
+    parts.push("")
+  }
+
+  if (task) {
+    parts.push(`## Task`)
+    parts.push(task)
+    parts.push("")
+    parts.push("Implement this with production-grade design quality. Make it look like a professional designer built it.")
+  } else {
+    parts.push("No task specified. Usage: /design <description of what to build>")
+  }
+
+  return parts.join("\n")
+}