@kkelly-offical/kkcode 0.1.2

package/src/plugin/builtin-hooks/console-warn.mjs

@@ -0,0 +1,41 @@
+// Console.log warning hook
+// Warns when console.log is present in edited production files
+
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+
+const PRODUCTION_FILE = /\.(js|jsx|ts|tsx|mjs|cjs)$/
+const IGNORE_PATH = /(test|spec|__tests__|__mocks__|\.test\.|\.spec\.|\.config\.)/i
+
+export default {
+  name: "console-warn",
+  tool: {
+    async after(payload) {
+      const { toolName, args, result, cwd } = payload
+      if (!["edit", "write"].includes(toolName)) return payload
+
+      const file = args?.path
+      if (!file) return payload
+      if (!PRODUCTION_FILE.test(file)) return payload
+      if (IGNORE_PATH.test(file)) return payload
+
+      const target = path.resolve(cwd || process.cwd(), file)
+      try {
+        const content = await readFile(target, "utf8")
+        const matches = content.match(/console\.(log|debug|info)\(/g)
+        if (matches && matches.length > 0) {
+          const warning = `\n⚠ Found ${matches.length} console.log/debug/info call(s) in ${file}. Consider removing before production.`
+          if (typeof result === "string") {
+            payload.result = result + warning
+          } else if (result && typeof result === "object") {
+            payload.result = { ...result, output: (result.output || "") + warning }
+          }
+        }
+      } catch {
+        // File not readable, skip
+      }
+
+      return payload
+    }
+  }
+}

package/src/plugin/builtin-hooks/extract-patterns.mjs

@@ -0,0 +1,75 @@
+// Extract patterns hook
+// Before compaction, analyzes the conversation for repeatable patterns and saves as instincts
+
+import { addInstinct } from "../../session/instinct-manager.mjs"
+
+// Patterns we look for in tool usage sequences
+const PATTERN_SIGNALS = [
+  { regex: /always run.*test/i, pattern: "Always run tests after code changes", category: "workflow" },
+  { regex: /npm audit|pip audit|cargo audit/i, pattern: "Run dependency audit after adding packages", category: "security" },
+  { regex: /git add.*&&.*git commit/i, pattern: "Stage specific files rather than using git add -A", category: "workflow" },
+  { regex: /\.test\.(ts|js|tsx|jsx)|_test\.go|test_.*\.py/i, pattern: "Co-locate test files with implementation", category: "testing" },
+  { regex: /prettier|eslint --fix|black |ruff /i, pattern: "Format code after editing", category: "coding" },
+  { regex: /tsconfig|tsc --noEmit/i, pattern: "Verify TypeScript types after changes", category: "coding" }
+]
+
+export default {
+  name: "extract-patterns",
+  session: {
+    async compacting(payload) {
+      const { messages, cwd } = payload
+      if (!messages || !Array.isArray(messages) || !cwd) return payload
+
+      // Scan assistant messages for pattern signals
+      const textContent = messages
+        .filter((m) => m.role === "assistant")
+        .map((m) => {
+          if (typeof m.content === "string") return m.content
+          if (Array.isArray(m.content)) {
+            return m.content
+              .filter((b) => b.type === "text")
+              .map((b) => b.text)
+              .join(" ")
+          }
+          return ""
+        })
+        .join("\n")
+
+      for (const signal of PATTERN_SIGNALS) {
+        if (signal.regex.test(textContent)) {
+          try {
+            await addInstinct(cwd, signal.pattern, signal.category)
+          } catch {
+            // Non-critical — skip on failure
+          }
+        }
+      }
+
+      // Look for user-confirmed patterns ("always do X", "never do Y", "remember to Z")
+      const userText = messages
+        .filter((m) => m.role === "user")
+        .map((m) => (typeof m.content === "string" ? m.content : ""))
+        .join("\n")
+
+      const alwaysMatch = userText.match(/(?:always|每次都要|总是)\s+(.{10,80})/gi)
+      if (alwaysMatch) {
+        for (const match of alwaysMatch.slice(0, 3)) {
+          try {
+            await addInstinct(cwd, match.trim(), "workflow")
+          } catch { /* skip */ }
+        }
+      }
+
+      const neverMatch = userText.match(/(?:never|不要|禁止)\s+(.{10,80})/gi)
+      if (neverMatch) {
+        for (const match of neverMatch.slice(0, 3)) {
+          try {
+            await addInstinct(cwd, match.trim(), "workflow")
+          } catch { /* skip */ }
+        }
+      }
+
+      return payload
+    }
+  }
+}

package/src/plugin/builtin-hooks/post-edit-format.mjs

@@ -0,0 +1,57 @@
+// Post-edit auto-format hook
+// Runs prettier on JS/TS/CSS/JSON files after edit, if prettier is installed
+
+import { exec as execCb } from "node:child_process"
+import { promisify } from "node:util"
+import { access } from "node:fs/promises"
+import path from "node:path"
+
+const exec = promisify(execCb)
+
+const FORMATTABLE = /\.(js|jsx|ts|tsx|css|scss|less|json|md|yaml|yml|html|vue|svelte)$/
+
+async function fileExists(p) {
+  try { await access(p); return true } catch { return false }
+}
+
+export default {
+  name: "post-edit-format",
+  tool: {
+    async after(payload) {
+      const { toolName, args, cwd } = payload
+      if (!["edit", "write", "multiedit"].includes(toolName)) return payload
+
+      // Collect affected files
+      const files = []
+      if (args?.path) files.push(args.path)
+      if (args?.changes) {
+        for (const c of args.changes) {
+          if (c.path) files.push(c.path)
+        }
+      }
+
+      const formattable = files.filter(f => FORMATTABLE.test(f))
+      if (formattable.length === 0) return payload
+
+      const root = cwd || process.cwd()
+
+      // Check if prettier is available (package.json devDependency or global)
+      const pkgPath = path.join(root, "node_modules", ".bin", "prettier")
+      if (!(await fileExists(pkgPath))) return payload
+
+      for (const file of formattable) {
+        const target = path.resolve(root, file)
+        try {
+          await exec(`npx prettier --write "${target}"`, {
+            cwd: root,
+            timeout: 10000
+          })
+        } catch {
+          // Formatting failure is non-critical, silently skip
+        }
+      }
+
+      return payload
+    }
+  }
+}

package/src/plugin/builtin-hooks/post-edit-typecheck.mjs

@@ -0,0 +1,61 @@
+// Post-edit TypeScript type check hook
+// Runs `tsc --noEmit` after editing .ts/.tsx files to catch type errors early
+
+import { exec as execCb } from "node:child_process"
+import { promisify } from "node:util"
+import { access } from "node:fs/promises"
+import path from "node:path"
+
+const exec = promisify(execCb)
+
+async function fileExists(p) {
+  try { await access(p); return true } catch { return false }
+}
+
+export default {
+  name: "post-edit-typecheck",
+  tool: {
+    async after(payload) {
+      const { toolName, args, result, cwd } = payload
+      if (!["edit", "write", "multiedit"].includes(toolName)) return payload
+
+      // Determine affected files
+      const files = []
+      if (args?.path) files.push(args.path)
+      if (args?.changes) {
+        for (const c of args.changes) {
+          if (c.path) files.push(c.path)
+        }
+      }
+
+      // Only check if at least one TS/TSX file was edited
+      const tsFiles = files.filter(f => /\.tsx?$/.test(f))
+      if (tsFiles.length === 0) return payload
+
+      // Verify tsconfig.json exists in project
+      const tsconfigPath = path.join(cwd || process.cwd(), "tsconfig.json")
+      if (!(await fileExists(tsconfigPath))) return payload
+
+      try {
+        await exec("npx tsc --noEmit --pretty 2>&1", {
+          cwd: cwd || process.cwd(),
+          timeout: 15000
+        })
+        // No errors — silently pass through
+      } catch (error) {
+        const output = (error.stdout || error.stderr || "").trim()
+        if (output) {
+          // Append type check warnings to tool result
+          const warning = `\n⚠ TypeScript type check found issues:\n${output.slice(0, 2000)}`
+          if (typeof result === "string") {
+            payload.result = result + warning
+          } else if (result && typeof result === "object") {
+            payload.result = { ...result, output: (result.output || "") + warning }
+          }
+        }
+      }
+
+      return payload
+    }
+  }
+}

package/src/plugin/builtin-hooks/strategic-compaction.mjs

@@ -0,0 +1,38 @@
+// Strategic compaction suggestion hook
+// Suggests /compact at logical breakpoints instead of waiting for automatic compaction
+
+let toolCallCount = 0
+let lastSuggestionAt = 0
+const THRESHOLD = 30 // suggest every ~30 tool calls
+
+export default {
+  name: "strategic-compaction",
+  tool: {
+    async after(payload) {
+      toolCallCount++
+
+      // Only suggest periodically
+      if (toolCallCount - lastSuggestionAt < THRESHOLD) return payload
+
+      const { toolName, result } = payload
+
+      // Detect logical breakpoints: after research phases, after build/test, after multi-file edits
+      const isResearchEnd = toolName === "grep" || toolName === "glob" || toolName === "read"
+      const isBuildEnd = toolName === "bash"
+      const isEditEnd = toolName === "edit" || toolName === "write" || toolName === "multiedit"
+
+      if (!isResearchEnd && !isBuildEnd && !isEditEnd) return payload
+
+      lastSuggestionAt = toolCallCount
+      const suggestion = `\n💡 You've made ${toolCallCount} tool calls in this session. Consider running /compact to free up context space if the conversation is getting long.`
+
+      if (typeof result === "string") {
+        payload.result = result + suggestion
+      } else if (result && typeof result === "object") {
+        payload.result = { ...result, output: (result.output || "") + suggestion }
+      }
+
+      return payload
+    }
+  }
+}

package/src/plugin/hook-bus.mjs

@@ -0,0 +1,154 @@
+import path from "node:path"
+import { access, readdir } from "node:fs/promises"
+import { pathToFileURL, fileURLToPath } from "node:url"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const HOOK_EVENTS = [
+  "chat.params",
+  "chat.message",
+  "messages.transform",
+  "tool.before",
+  "tool.after",
+  "event",
+  "session.compacting"
+]
+
+const state = {
+  loaded: false,
+  hooks: [],
+  errors: []
+}
+
+function normalizeHook(mod, source) {
+  const hook = mod.default || mod
+  if (!hook || typeof hook !== "object") return null
+  return {
+    source,
+    name: hook.name || path.basename(source),
+    chat: hook.chat || {},
+    tool: hook.tool || {},
+    event: typeof hook.event === "function" ? hook.event : null,
+    session: hook.session || {}
+  }
+}
+
+async function exists(target) {
+  try {
+    await access(target)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function discover(dir) {
+  if (!(await exists(dir))) return []
+  const entries = await readdir(dir, { withFileTypes: true })
+  return entries
+    .filter((entry) => entry.isFile() && [".mjs", ".js"].includes(path.extname(entry.name).toLowerCase()))
+    .map((entry) => path.join(dir, entry.name))
+}
+
+async function loadModule(file) {
+  try {
+    const mod = await import(pathToFileURL(file).href)
+    return { hook: normalizeHook(mod, file), error: null }
+  } catch (error) {
+    return { hook: null, error: `${file}: ${error.message}` }
+  }
+}
+
+export async function initHookBus(cwd = process.cwd()) {
+  if (state.loaded) return state
+  // Built-in hooks ship with kkcode (lowest priority — user hooks can override)
+  const builtinHooks = path.join(__dirname, "builtin-hooks")
+  const userRoot = process.env.USERPROFILE || process.env.HOME || cwd
+  const userHooks = path.join(userRoot, ".kkcode", "hooks")
+  const projectHooks = path.join(cwd, ".kkcode", "hooks")
+  // Load order: builtin → user → project (later hooks in chain take priority)
+  const files = [...(await discover(builtinHooks)), ...(await discover(userHooks)), ...(await discover(projectHooks))]
+  for (const file of files) {
+    const loaded = await loadModule(file)
+    if (loaded.error) {
+      state.errors.push(loaded.error)
+      continue
+    }
+    if (loaded.hook) state.hooks.push(loaded.hook)
+  }
+  state.loaded = true
+  return state
+}
+
+async function applyTransformChain(initial, chain) {
+  let current = initial
+  for (const fn of chain) {
+    const next = await fn(current)
+    if (next !== undefined) current = next
+  }
+  return current
+}
+
+export const HookBus = {
+  supportedEvents() {
+    return [...HOOK_EVENTS]
+  },
+  list() {
+    return state.hooks.map((hook) => ({ name: hook.name, source: hook.source }))
+  },
+  errors() {
+    return [...state.errors]
+  },
+  async chatParams(payload) {
+    const chain = state.hooks
+      .map((hook) => hook.chat?.params)
+      .filter((fn) => typeof fn === "function")
+      .map((fn) => async (current) => fn(current))
+    return applyTransformChain(payload, chain)
+  },
+  async chatMessage(payload) {
+    const chain = state.hooks
+      .map((hook) => hook.chat?.message)
+      .filter((fn) => typeof fn === "function")
+      .map((fn) => async (current) => fn(current))
+    return applyTransformChain(payload, chain)
+  },
+  async messagesTransform(payload) {
+    const chain = state.hooks
+      .map((hook) => hook.chat?.messagesTransform)
+      .filter((fn) => typeof fn === "function")
+      .map((fn) => async (current) => fn(current))
+    return applyTransformChain(payload, chain)
+  },
+  async toolBefore(payload) {
+    const chain = state.hooks
+      .map((hook) => hook.tool?.before)
+      .filter((fn) => typeof fn === "function")
+      .map((fn) => async (current) => fn(current))
+    return applyTransformChain(payload, chain)
+  },
+  async toolAfter(payload) {
+    const chain = state.hooks
+      .map((hook) => hook.tool?.after)
+      .filter((fn) => typeof fn === "function")
+      .map((fn) => async (current) => fn(current))
+    return applyTransformChain(payload, chain)
+  },
+  async emit(eventType, payload) {
+    for (const hook of state.hooks) {
+      if (!hook.event) continue
+      try {
+        await hook.event({ type: eventType, payload })
+      } catch (err) {
+        console.error(`[hook-bus] emit error in ${hook.name}:`, err?.message || err)
+      }
+    }
+  },
+  async sessionCompacting(payload) {
+    const chain = state.hooks
+      .map((hook) => hook.session?.compacting)
+      .filter((fn) => typeof fn === "function")
+      .map((fn) => async (current) => fn(current))
+    return applyTransformChain(payload, chain)
+  }
+}