@kkelly-offical/kkcode 0.1.2

package/src/storage/ghost-commit-store.mjs

@@ -0,0 +1,235 @@
+import path from "node:path"
+import { mkdir, readdir, readFile, writeFile, unlink } from "node:fs/promises"
+import { userRootDir } from "./paths.mjs"
+
+const GHOST_COMMIT_DIR = "ghost-commits"
+const MAX_GHOST_COMMITS_PER_REPO = 50 // 每个仓库最多保留的幽灵提交数
+const GHOST_COMMIT_TTL_MS = 7 * 24 * 60 * 60 * 1000 // 7天过期
+
+/**
+ * Ghost Commit 存储管理
+ * 
+ * 提供幽灵提交的持久化存储、查询、清理等功能。
+ * 存储位置: ~/.kkcode/ghost-commits/
+ */
+
+/** 获取幽灵提交存储目录 */
+export function getGhostCommitDir() {
+  return path.join(userRootDir(), GHOST_COMMIT_DIR)
+}
+
+/** 获取仓库的存储目录（基于 repoPath 的哈希） */
+function getRepoDir(repoPath) {
+  // 使用简单的哈希来避免路径中的特殊字符问题
+  const hash = Buffer.from(repoPath).toString("base64url")
+  return path.join(getGhostCommitDir(), hash)
+}
+
+/** 确保目录存在 */
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true })
+}
+
+/**
+ * 保存幽灵提交元数据
+ * 
+ * @param {Object} ghostCommit - 幽灵提交信息
+ * @param {string} ghostCommit.id - 唯一ID
+ * @param {string} ghostCommit.commitHash - Git commit hash
+ * @param {string} ghostCommit.repoPath - 仓库路径
+ * @param {string} ghostCommit.parentHash - 父提交hash
+ * @param {string} ghostCommit.message - 提交信息
+ * @param {number} ghostCommit.createdAt - 创建时间戳
+ * @param {string[]} ghostCommit.files - 包含的文件列表
+ */
+export async function saveGhostCommit(ghostCommit) {
+  const repoDir = getRepoDir(ghostCommit.repoPath)
+  await ensureDir(repoDir)
+
+  const filePath = path.join(repoDir, `${ghostCommit.id}.json`)
+  const data = {
+    ...ghostCommit,
+    savedAt: Date.now()
+  }
+
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf8")
+
+  // 清理旧的幽灵提交
+  await cleanupOldGhostCommits(ghostCommit.repoPath)
+
+  return { ok: true, path: filePath }
+}
+
+/**
+ * 加载幽灵提交元数据
+ * 
+ * @param {string} repoPath - 仓库路径
+ * @param {string} ghostCommitId - 幽灵提交ID
+ * @returns {Promise<Object|null>}
+ */
+export async function loadGhostCommit(repoPath, ghostCommitId) {
+  const repoDir = getRepoDir(repoPath)
+  const filePath = path.join(repoDir, `${ghostCommitId}.json`)
+
+  try {
+    const content = await readFile(filePath, "utf8")
+    return JSON.parse(content)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 列出仓库的所有幽灵提交
+ * 
+ * @param {string} repoPath - 仓库路径
+ * @param {Object} options - 选项
+ * @param {boolean} [options.includeExpired=false] - 是否包含已过期的
+ * @returns {Promise<Array<Object>>}
+ */
+export async function listGhostCommits(repoPath, options = {}) {
+  const { includeExpired = false } = options
+  const repoDir = getRepoDir(repoPath)
+
+  try {
+    const entries = await readdir(repoDir, { withFileTypes: true })
+    const commits = []
+
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue
+
+      try {
+        const content = await readFile(path.join(repoDir, entry.name), "utf8")
+        const commit = JSON.parse(content)
+
+        // 检查是否过期
+        const isExpired = Date.now() - commit.createdAt > GHOST_COMMIT_TTL_MS
+        if (!includeExpired && isExpired) {
+          // 删除过期文件
+          await unlink(path.join(repoDir, entry.name)).catch(() => {})
+          continue
+        }
+
+        commits.push({
+          ...commit,
+          isExpired
+        })
+      } catch {
+        // 跳过无效文件
+      }
+    }
+
+    // 按创建时间降序排列
+    return commits.sort((a, b) => b.createdAt - a.createdAt)
+  } catch {
+    return []
+  }
+}
+
+/**
+ * 删除幽灵提交
+ * 
+ * @param {string} repoPath - 仓库路径
+ * @param {string} ghostCommitId - 幽灵提交ID
+ * @returns {Promise<boolean>}
+ */
+export async function deleteGhostCommit(repoPath, ghostCommitId) {
+  const repoDir = getRepoDir(repoPath)
+  const filePath = path.join(repoDir, `${ghostCommitId}.json`)
+
+  try {
+    await unlink(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 清理旧的幽灵提交
+ * 保留最新的 MAX_GHOST_COMMITS_PER_REPO 个
+ * 
+ * @param {string} repoPath - 仓库路径
+ */
+export async function cleanupOldGhostCommits(repoPath) {
+  const commits = await listGhostCommits(repoPath, { includeExpired: true })
+
+  if (commits.length <= MAX_GHOST_COMMITS_PER_REPO) {
+    return
+  }
+
+  // 删除多余的旧提交
+  const toDelete = commits.slice(MAX_GHOST_COMMITS_PER_REPO)
+  for (const commit of toDelete) {
+    await deleteGhostCommit(repoPath, commit.id)
+  }
+}
+
+/**
+ * 清理所有过期的幽灵提交
+ * 
+ * @returns {Promise<{deleted: number}>}
+ */
+export async function cleanupAllExpired() {
+  const baseDir = getGhostCommitDir()
+  let deleted = 0
+
+  try {
+    const repoDirs = await readdir(baseDir, { withFileTypes: true })
+    
+    for (const dir of repoDirs) {
+      if (!dir.isDirectory()) continue
+
+      const repoPath = path.join(baseDir, dir.name)
+      try {
+        const files = await readdir(repoPath)
+        
+        for (const file of files) {
+          if (!file.endsWith(".json")) continue
+
+          try {
+            const content = await readFile(path.join(repoPath, file), "utf8")
+            const commit = JSON.parse(content)
+            
+            const isExpired = Date.now() - commit.createdAt > GHOST_COMMIT_TTL_MS
+            if (isExpired) {
+              await unlink(path.join(repoPath, file))
+              deleted++
+            }
+          } catch {
+            // 跳过无效文件
+          }
+        }
+      } catch {
+        // 跳过无法读取的目录
+      }
+    }
+  } catch {
+    // 目录可能不存在
+  }
+
+  return { deleted }
+}
+
+/**
+ * 获取最新的幽灵提交
+ * 
+ * @param {string} repoPath - 仓库路径
+ * @returns {Promise<Object|null>}
+ */
+export async function getLatestGhostCommit(repoPath) {
+  const commits = await listGhostCommits(repoPath)
+  return commits[0] || null
+}
+
+/**
+ * 统计幽灵提交数量
+ * 
+ * @param {string} repoPath - 仓库路径
+ * @returns {Promise<{total: number, expired: number}>}
+ */
+export async function countGhostCommits(repoPath) {
+  const commits = await listGhostCommits(repoPath, { includeExpired: true })
+  const expired = commits.filter(c => c.isExpired).length
+  return { total: commits.length, expired }
+}

package/src/storage/json-store.mjs

@@ -0,0 +1,53 @@
+import path from "node:path"
+import { readFile, writeFile, rename, unlink, mkdir } from "node:fs/promises"
+
+export async function readJson(file, fallback) {
+  try {
+    const content = await readFile(file, "utf8")
+    return JSON.parse(content)
+  } catch {
+    return fallback
+  }
+}
+
+export async function writeJsonAtomic(file, value) {
+  const dir = path.dirname(file)
+  const tmp = `${file}.tmp.${process.pid}.${Date.now()}`
+  await mkdir(dir, { recursive: true })
+  await writeFile(tmp, JSON.stringify(value, null, 2) + "\n", "utf8")
+
+  // Windows can temporarily lock files and make atomic rename fail with EPERM/EBUSY.
+  // Retry briefly, then fall back to direct write to keep data durable.
+  let renamed = false
+  let lastError = null
+  const retries = [10, 30, 80, 160, 300]
+  for (const delay of retries) {
+    try {
+      await rename(tmp, file)
+      renamed = true
+      break
+    } catch (error) {
+      lastError = error
+      if (!["EPERM", "EBUSY", "EACCES"].includes(error?.code)) {
+        break
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay))
+    }
+  }
+
+  if (!renamed) {
+    try {
+      await writeFile(file, JSON.stringify(value, null, 2) + "\n", "utf8")
+      renamed = true
+    } catch (fallbackError) {
+      lastError = fallbackError
+    }
+  }
+
+  await unlink(tmp).catch(() => {})
+  if (!renamed && lastError) throw lastError
+}
+
+export async function writeJson(file, value) {
+  await writeJsonAtomic(file, value)
+}

package/src/storage/paths.mjs

@@ -0,0 +1,148 @@
+import os from "node:os"
+import path from "node:path"
+import { createHash } from "node:crypto"
+import { mkdir } from "node:fs/promises"
+
+export function userRootDir() {
+  return process.env.KKCODE_HOME || path.join(os.homedir(), ".kkcode")
+}
+
+export function projectRootDir(cwd = process.cwd()) {
+  return path.join(cwd, ".kkcode")
+}
+
+export function userConfigCandidates() {
+  const root = userRootDir()
+  return [
+    path.join(root, "config.yaml"),
+    path.join(root, "config.yml"),
+    path.join(root, "config.json"),
+    path.join(root, "kkcode.config.yaml"),
+    path.join(root, "kkcode.config.yml"),
+    path.join(root, "kkcode.config.json")
+  ]
+}
+
+export function projectConfigCandidates(cwd = process.cwd()) {
+  return [
+    path.join(cwd, "kkcode.config.yaml"),
+    path.join(cwd, "kkcode.config.yml"),
+    path.join(cwd, "kkcode.config.json"),
+    path.join(projectRootDir(cwd), "config.yaml"),
+    path.join(projectRootDir(cwd), "config.yml"),
+    path.join(projectRootDir(cwd), "config.json")
+  ]
+}
+
+export function usageStorePath() {
+  return path.join(userRootDir(), "usage.json")
+}
+
+export function trustFilePath(cwd = process.cwd()) {
+  return path.join(projectRootDir(cwd), "trust.json")
+}
+
+export function reviewStorePath(cwd = process.cwd()) {
+  return path.join(projectRootDir(cwd), "review-state.json")
+}
+
+export function sessionStorePath() {
+  // Legacy monolithic store path kept for migration.
+  return path.join(userRootDir(), "session-store.json")
+}
+
+export function sessionShardRootPath() {
+  return path.join(userRootDir(), "sessions")
+}
+
+export function sessionIndexPath() {
+  return path.join(sessionShardRootPath(), "index.json")
+}
+
+export function sessionDataPath(sessionId) {
+  return path.join(sessionShardRootPath(), `${sessionId}.json`)
+}
+
+export function backgroundTaskStorePath() {
+  return path.join(userRootDir(), "background-tasks.json")
+}
+
+export function backgroundTaskRuntimeDir() {
+  return path.join(userRootDir(), "tasks")
+}
+
+export function backgroundTaskLogPath(taskId) {
+  return path.join(backgroundTaskRuntimeDir(), `${taskId}.log`)
+}
+
+export function backgroundTaskCheckpointPath(taskId) {
+  return path.join(backgroundTaskRuntimeDir(), `${taskId}.json`)
+}
+
+export function sessionCheckpointRootPath() {
+  return path.join(userRootDir(), "checkpoints")
+}
+
+export function sessionCheckpointPath(sessionId, name = "latest") {
+  return path.join(sessionCheckpointRootPath(), sessionId, `${name}.json`)
+}
+
+export function legacySessionStorePath() {
+  return path.join(userRootDir(), "session-store.json")
+}
+
+export function reviewRejectionQueuePath(cwd = process.cwd()) {
+  return path.join(projectRootDir(cwd), "review-rejections.json")
+}
+
+export function eventLogPath() {
+  return path.join(userRootDir(), "events.log")
+}
+
+export function auditStorePath() {
+  return path.join(userRootDir(), "audit-log.json")
+}
+
+export async function ensureUserRoot() {
+  await mkdir(userRootDir(), { recursive: true })
+}
+
+export async function ensureProjectRoot(cwd = process.cwd()) {
+  await mkdir(projectRootDir(cwd), { recursive: true })
+}
+
+export async function ensureSessionShardRoot() {
+  await mkdir(sessionShardRootPath(), { recursive: true })
+}
+
+export async function ensureBackgroundTaskRuntimeDir() {
+  await mkdir(backgroundTaskRuntimeDir(), { recursive: true })
+}
+
+// Auto Memory — persistent per-project memory directory
+export function memoryDir(cwd = process.cwd()) {
+  const hash = createHash("md5").update(cwd).digest("hex").slice(0, 12)
+  const safeName = path.basename(cwd).replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 30)
+  return path.join(userRootDir(), "projects", `${safeName}_${hash}`, "memory")
+}
+
+export function memoryFilePath(cwd = process.cwd()) {
+  return path.join(memoryDir(cwd), "MEMORY.md")
+}
+
+export async function ensureMemoryDir(cwd = process.cwd()) {
+  await mkdir(memoryDir(cwd), { recursive: true })
+}
+
+// GitHub integration
+export function githubTokenPath() {
+  return path.join(userRootDir(), "github-token.json")
+}
+
+export function githubReposDir() {
+  return path.join(userRootDir(), "repos")
+}
+
+export async function ensureGithubReposDir() {
+  await mkdir(githubReposDir(), { recursive: true })
+}

package/src/theme/color.mjs

@@ -0,0 +1,64 @@
+const ANSI = {
+  reset: "\u001b[0m",
+  bold: "\u001b[1m",
+  dim: "\u001b[2m",
+  italic: "\u001b[3m",
+  underline: "\u001b[4m"
+}
+
+const NAMED = {
+  black: "\u001b[30m",
+  red: "\u001b[31m",
+  green: "\u001b[32m",
+  yellow: "\u001b[33m",
+  blue: "\u001b[34m",
+  magenta: "\u001b[35m",
+  cyan: "\u001b[36m",
+  white: "\u001b[37m"
+}
+
+function hexToRgb(hex) {
+  const raw = hex.replace("#", "")
+  return {
+    r: parseInt(raw.slice(0, 2), 16),
+    g: parseInt(raw.slice(2, 4), 16),
+    b: parseInt(raw.slice(4, 6), 16)
+  }
+}
+
+function fgColorCode(color) {
+  if (!color) return ""
+  if (NAMED[color]) return NAMED[color]
+  if (/^#([A-Fa-f0-9]{6})$/.test(color)) {
+    const { r, g, b } = hexToRgb(color)
+    return `\u001b[38;2;${r};${g};${b}m`
+  }
+  return ""
+}
+
+function bgColorCode(color) {
+  if (!color) return ""
+  if (NAMED[color]) {
+    const fg = NAMED[color]
+    return fg.replace("[3", "[4")
+  }
+  if (/^#([A-Fa-f0-9]{6})$/.test(color)) {
+    const { r, g, b } = hexToRgb(color)
+    return `\u001b[48;2;${r};${g};${b}m`
+  }
+  return ""
+}
+
+export function paint(text, color, options = {}) {
+  if (!process.stdout.isTTY || process.env.NO_COLOR) return text
+  const styles = []
+  if (options.bold) styles.push(ANSI.bold)
+  if (options.dim) styles.push(ANSI.dim)
+  if (options.italic) styles.push(ANSI.italic)
+  if (options.underline) styles.push(ANSI.underline)
+  const style = styles.join("")
+  const fg = fgColorCode(color)
+  const bg = bgColorCode(options.bg || null)
+  if (!fg && !bg && !style) return text
+  return `${style}${fg}${bg}${text}${ANSI.reset}`
+}

package/src/theme/default-theme.mjs

@@ -0,0 +1,29 @@
+export const DEFAULT_THEME = {
+  name: "neo-contrast",
+  base: {
+    bg: "#0b0b0b",
+    fg: "#f5f7fa",
+    muted: "#c3d2e8",
+    border: "#5b6b85",
+    accent: "#22d3ee"
+  },
+  semantic: {
+    info: "#60a5fa",
+    warn: "#fbbf24",
+    error: "#f87171",
+    success: "#34d399"
+  },
+  modes: {
+    ask: "#7aa2f7",
+    plan: "#2dd4bf",
+    agent: "#4ade80",
+    longagent: "#fb923c"
+  },
+  components: {
+    panel: "#111827",
+    header: "#e2e8f0",
+    footer: "#94a3b8",
+    diff_add: "#22c55e",
+    diff_del: "#ef4444"
+  }
+}

package/src/theme/load-theme.mjs

@@ -0,0 +1,71 @@
+import path from "node:path"
+import { access, readFile } from "node:fs/promises"
+import YAML from "yaml"
+import { DEFAULT_THEME } from "./default-theme.mjs"
+import { validateTheme } from "./schema.mjs"
+
+async function exists(file) {
+  try {
+    await access(file)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function parseTheme(file, raw) {
+  if (file.endsWith(".json")) return JSON.parse(raw)
+  return YAML.parse(raw)
+}
+
+function deepMerge(base, override) {
+  if (override === null || override === undefined) return base
+  if (Array.isArray(override)) return [...override]
+  if (typeof override !== "object") return override
+  if (!base || typeof base !== "object" || Array.isArray(base)) return override
+  const out = { ...base }
+  for (const key of Object.keys(override)) {
+    out[key] = deepMerge(base[key], override[key])
+  }
+  return out
+}
+
+function resolveConfiguredThemePath(configState) {
+  const projectTheme = configState.source.projectRaw?.ui?.theme_file
+  if (typeof projectTheme === "string" && projectTheme.trim()) {
+    return path.resolve(configState.source.projectDir ?? process.cwd(), projectTheme)
+  }
+  const userTheme = configState.source.userRaw?.ui?.theme_file
+  if (typeof userTheme === "string" && userTheme.trim()) {
+    return path.resolve(configState.source.userDir ?? process.cwd(), userTheme)
+  }
+  return null
+}
+
+export async function loadTheme(configState, fileOverride = null) {
+  const target = fileOverride ? path.resolve(fileOverride) : resolveConfiguredThemePath(configState)
+  if (!target || !(await exists(target))) {
+    return { theme: deepMerge(DEFAULT_THEME, { modes: configState.config.ui.mode_colors }), source: "default", errors: [] }
+  }
+  try {
+    const raw = await readFile(target, "utf8")
+    const parsed = parseTheme(target, raw)
+    const merged = deepMerge(DEFAULT_THEME, parsed)
+    merged.modes = deepMerge(merged.modes, configState.config.ui.mode_colors)
+    const check = validateTheme(merged)
+    if (!check.valid) {
+      return {
+        theme: deepMerge(DEFAULT_THEME, { modes: configState.config.ui.mode_colors }),
+        source: "default",
+        errors: check.errors.map((error) => `${target}: ${error}`)
+      }
+    }
+    return { theme: merged, source: target, errors: [] }
+  } catch (error) {
+    return {
+      theme: deepMerge(DEFAULT_THEME, { modes: configState.config.ui.mode_colors }),
+      source: "default",
+      errors: [`${target}: ${error.message}`]
+    }
+  }
+}