@kkelly-offical/kkcode 0.1.7 → 0.2.3-preview.1

package/src/commands/session.mjs

@@ -1,9 +1,10 @@
-import path from "node:path"
-import { writeFile } from "node:fs/promises"
-import { Command } from "commander"
+import path from "node:path"
+import { writeFile } from "node:fs/promises"
+import { Command } from "commander"
 import { exportSession, getSession, listSessions, forkSession, fsckSessionStore, gcSessionStore, flushNow } from "../session/store.mjs"
 import { newSessionId, executeTurn } from "../session/engine.mjs"
-import { listRecoverableSessions, getResumeContext, isRecoveryEnabled } from "../session/recovery.mjs"
+import { listRecoverableSessions, getResumeContext, isRecoveryEnabled, summarizeResumeContext } from "../session/recovery.mjs"
+import { summarizeSessionRuntimeState } from "../session/runtime-state.mjs"
 import { buildContext } from "../context.mjs"
 import { ToolRegistry } from "../tool/registry.mjs"
 
@@ -15,8 +16,8 @@ function assertRecoveryEnabled(config, commandName) {
 }
 
 export function createSessionCommand() {
-  const cmd = new Command("session").description("manage persisted kkcode sessions")
-
+  const cmd = new Command("session").description("manage persisted kkcode sessions")
+
   cmd
     .command("fsck")
     .description("check session index/data consistency")
@@ -62,86 +63,131 @@ export function createSessionCommand() {
 
   cmd
     .command("list")
-    .description("list sessions")
-    .option("--cwd-only", "filter by cwd", false)
-    .option("--roots", "only root sessions", false)
-    .option("--limit <n>", "max sessions", "30")
-    .action(async (options) => {
-      const list = await listSessions({
-        cwd: options.cwdOnly ? process.cwd() : null,
-        includeChildren: !options.roots,
-        limit: Number(options.limit || 30)
-      })
-      if (!list.length) {
-        console.log("no sessions found")
-        return
-      }
-      for (const session of list) {
-        const parent = session.parentSessionId ? ` parent=${session.parentSessionId}` : ""
-        console.log(
-          `${session.id}  ${session.mode}  ${session.providerType}  ${session.model}  ${new Date(session.updatedAt).toLocaleString()}${parent}`
-        )
-      }
-    })
-
-  cmd
-    .command("show")
-    .description("show one session")
-    .requiredOption("--id <id>", "session id")
-    .action(async (options) => {
-      const data = await getSession(options.id)
-      if (!data) {
-        console.error(`session not found: ${options.id}`)
-        process.exitCode = 1
-        return
-      }
-      console.log(JSON.stringify(data, null, 2))
-    })
-
-  cmd
-    .command("export")
-    .description("export session to json")
-    .requiredOption("--id <id>", "session id")
-    .option("--out <file>", "output file")
-    .action(async (options) => {
-      const data = await exportSession(options.id)
-      if (!data) {
-        console.error(`session not found: ${options.id}`)
-        process.exitCode = 1
-        return
-      }
-      const out = options.out ? path.resolve(options.out) : path.resolve(`session-${options.id}.json`)
-      await writeFile(out, JSON.stringify(data, null, 2) + "\n", "utf8")
-      console.log(`exported: ${out}`)
-    })
-
-  cmd
-    .command("fork")
-    .description("fork session into a new child session")
-    .requiredOption("--id <id>", "source session id")
-    .option("--new-id <id>", "new session id")
-    .option("--title <title>", "child title")
-    .action(async (options) => {
-      const newId = options.newId || newSessionId()
-      const out = await forkSession({
-        sessionId: options.id,
-        newSessionId: newId,
-        title: options.title || null
-      })
-      if (!out) {
-        console.error(`session not found: ${options.id}`)
-        process.exitCode = 1
-        return
-      }
-      console.log(`forked: ${newId} <- ${options.id}`)
-    })
-
-  cmd
-    .command("resume")
-    .description("resume a session from the last user message")
-    .requiredOption("--id <id>", "session id to resume")
-    .option("--mode <mode>", "override mode")
-    .option("--model <model>", "override model")
+    .description("list sessions")
+    .option("--cwd-only", "filter by cwd", false)
+    .option("--roots", "only root sessions", false)
+    .option("--limit <n>", "max sessions", "30")
+    .action(async (options) => {
+      const list = await listSessions({
+        cwd: options.cwdOnly ? process.cwd() : null,
+        includeChildren: !options.roots,
+        limit: Number(options.limit || 30)
+      })
+      if (!list.length) {
+        console.log("no sessions found")
+        return
+      }
+      for (const session of list) {
+        const parent = session.parentSessionId ? ` parent=${session.parentSessionId}` : ""
+        console.log(
+          `${session.id}  ${session.mode}  ${session.providerType}  ${session.model}  ${new Date(session.updatedAt).toLocaleString()}${parent}`
+        )
+      }
+    })
+
+  cmd
+    .command("status")
+    .description("show a unified runtime summary for the latest or selected session")
+    .option("--id <id>", "session id")
+    .option("--json", "print as json", false)
+    .action(async (options) => {
+      const ctx = await buildContext()
+      const summary = await summarizeSessionRuntimeState({
+        sessionId: options.id || null,
+        cwd: process.cwd(),
+        recoveryEnabled: isRecoveryEnabled(ctx.configState.config)
+      })
+
+      if (options.json) {
+        console.log(JSON.stringify(summary, null, 2))
+        return
+      }
+      if (!summary.session) {
+        console.log("no session state available")
+        return
+      }
+
+      console.log(`session=${summary.session.id} mode=${summary.session.mode} provider=${summary.session.providerType} model=${summary.session.model}`)
+      console.log(`status=${summary.session.status} messages=${summary.messageCount} parts=${summary.partCount}`)
+      if (summary.retryMeta) {
+        console.log(`retry=inProgress:${Boolean(summary.retryMeta.inProgress)} step=${summary.retryMeta.step ?? "-"}`)
+      }
+      if (summary.budgetState) {
+        console.log(`budget=exceeded:${Boolean(summary.budgetState.exceeded)} warnings=${(summary.budgetState.warnings || []).length}`)
+      }
+      console.log(`recoverable=${summary.recoverableCount}`)
+      console.log(`background total=${summary.background.total} running=${summary.background.running} pending=${summary.background.pending} interrupted=${summary.background.interrupted} error=${summary.background.error}`)
+      console.log(`audit total=${summary.audit.total} error1h=${summary.audit.error1h} error24h=${summary.audit.error24h}`)
+    })
+
+  cmd
+    .command("show")
+    .description("show one session")
+    .requiredOption("--id <id>", "session id")
+    .option("--summary", "show a concise session/resume summary")
+    .action(async (options) => {
+      const data = await getSession(options.id)
+      if (!data) {
+        console.error(`session not found: ${options.id}`)
+        process.exitCode = 1
+        return
+      }
+      if (options.summary) {
+        const resumeCtx = await getResumeContext(options.id)
+        const summary = summarizeResumeContext(resumeCtx)
+        console.log(JSON.stringify({
+          session: data.session,
+          resume: summary
+        }, null, 2))
+        return
+      }
+      console.log(JSON.stringify(data, null, 2))
+    })
+
+  cmd
+    .command("export")
+    .description("export session to json")
+    .requiredOption("--id <id>", "session id")
+    .option("--out <file>", "output file")
+    .action(async (options) => {
+      const data = await exportSession(options.id)
+      if (!data) {
+        console.error(`session not found: ${options.id}`)
+        process.exitCode = 1
+        return
+      }
+      const out = options.out ? path.resolve(options.out) : path.resolve(`session-${options.id}.json`)
+      await writeFile(out, JSON.stringify(data, null, 2) + "\n", "utf8")
+      console.log(`exported: ${out}`)
+    })
+
+  cmd
+    .command("fork")
+    .description("fork session into a new child session")
+    .requiredOption("--id <id>", "source session id")
+    .option("--new-id <id>", "new session id")
+    .option("--title <title>", "child title")
+    .action(async (options) => {
+      const newId = options.newId || newSessionId()
+      const out = await forkSession({
+        sessionId: options.id,
+        newSessionId: newId,
+        title: options.title || null
+      })
+      if (!out) {
+        console.error(`session not found: ${options.id}`)
+        process.exitCode = 1
+        return
+      }
+      console.log(`forked: ${newId} <- ${options.id}`)
+    })
+
+  cmd
+    .command("resume")
+    .description("resume a session from the last user message")
+    .requiredOption("--id <id>", "session id to resume")
+    .option("--mode <mode>", "override mode")
+    .option("--model <model>", "override model")
     .action(async (options) => {
       const ctx = await buildContext()
       if (!assertRecoveryEnabled(ctx.configState.config, "session resume")) return
@@ -152,31 +198,31 @@ export function createSessionCommand() {
         process.exitCode = 1
         return
       }
-      if (!resumeCtx.canResume) {
-        console.error(`no user message found in session ${options.id}`)
-        process.exitCode = 1
-        return
-      }
+      if (!resumeCtx.canResume) {
+        console.error(`no user message found in session ${options.id}`)
+        process.exitCode = 1
+        return
+      }
       await ToolRegistry.initialize({ config: ctx.configState.config, cwd: process.cwd() })
       const mode = options.mode || resumeCtx.session.mode
       const model = options.model || resumeCtx.session.model
-      console.log(`resuming session ${options.id} (${resumeCtx.messageCount} messages)`)
-      console.log(`last prompt: ${resumeCtx.lastPrompt.slice(0, 100)}${resumeCtx.lastPrompt.length > 100 ? "..." : ""}`)
-      const result = await executeTurn({
-        prompt: resumeCtx.lastPrompt,
-        mode,
-        model,
-        sessionId: options.id,
-        configState: ctx.configState,
-        providerType: resumeCtx.session.providerType
-      })
-      console.log(result.reply)
-    })
-
-  cmd
+      console.log(`resuming session ${options.id} (${resumeCtx.messageCount} messages)`)
+      console.log(`last prompt: ${resumeCtx.lastPrompt.slice(0, 100)}${resumeCtx.lastPrompt.length > 100 ? "..." : ""}`)
+      const result = await executeTurn({
+        prompt: resumeCtx.lastPrompt,
+        mode,
+        model,
+        sessionId: options.id,
+        configState: ctx.configState,
+        providerType: resumeCtx.session.providerType
+      })
+      console.log(result.reply)
+    })
+
+  cmd
     .command("retry")
-    .description("retry the last failed turn in a session")
-    .requiredOption("--id <id>", "session id to retry")
+    .description("retry the last failed turn in a session")
+    .requiredOption("--id <id>", "session id to retry")
     .action(async (options) => {
       const ctx = await buildContext()
       if (!assertRecoveryEnabled(ctx.configState.config, "session retry")) return
@@ -186,34 +232,35 @@ export function createSessionCommand() {
         console.error(`session not found: ${options.id}`)
         process.exitCode = 1
         return
-      }
-      if (!resumeCtx.canRetry) {
-        console.error(`session ${options.id} has no failed turn to retry`)
-        process.exitCode = 1
-        return
-      }
-      if (!resumeCtx.canResume) {
-        console.error(`no user message found in session ${options.id}`)
-        process.exitCode = 1
-        return
-      }
+      }
+      if (!resumeCtx.canRetry) {
+        console.error(`session ${options.id} has no failed turn to retry`)
+        process.exitCode = 1
+        return
+      }
+      if (!resumeCtx.canResume) {
+        console.error(`no user message found in session ${options.id}`)
+        process.exitCode = 1
+        return
+      }
       await ToolRegistry.initialize({ config: ctx.configState.config, cwd: process.cwd() })
       console.log(`retrying failed turn in session ${options.id}`)
-      const result = await executeTurn({
-        prompt: resumeCtx.lastPrompt,
-        mode: resumeCtx.session.mode,
-        model: resumeCtx.session.model,
-        sessionId: options.id,
-        configState: ctx.configState,
-        providerType: resumeCtx.session.providerType
-      })
-      console.log(result.reply)
-    })
-
-  cmd
+      const result = await executeTurn({
+        prompt: resumeCtx.lastPrompt,
+        mode: resumeCtx.session.mode,
+        model: resumeCtx.session.model,
+        sessionId: options.id,
+        configState: ctx.configState,
+        providerType: resumeCtx.session.providerType
+      })
+      console.log(result.reply)
+    })
+
+  cmd
     .command("recoverable")
     .description("list sessions that can be resumed or retried")
-    .action(async () => {
+    .option("--json", "print as json", false)
+    .action(async (options) => {
       const ctx = await buildContext()
       if (!assertRecoveryEnabled(ctx.configState.config, "session recoverable")) return
 
@@ -224,12 +271,20 @@ export function createSessionCommand() {
       if (!sessions.length) {
         console.log("no recoverable sessions")
         return
-      }
-      for (const s of sessions) {
-        const reason = s.retryMeta?.inProgress ? "in-progress" : s.status === "error" ? "error" : "unknown"
-        console.log(`${s.id}  ${s.mode}  ${reason}  ${new Date(s.updatedAt).toLocaleString()}`)
-      }
-    })
-
-  return cmd
-}
+      }
+      if (options.json) {
+        const payload = await Promise.all(sessions.map(async (session) => ({
+          session,
+          resume: summarizeResumeContext(await getResumeContext(session.id, { enabled: true }))
+        })))
+        console.log(JSON.stringify(payload, null, 2))
+        return
+      }
+      for (const s of sessions) {
+        const summary = summarizeResumeContext(await getResumeContext(s.id, { enabled: true }))
+        console.log(`${s.id}  ${s.mode}  ${summary?.status || "unknown"}  ${new Date(s.updatedAt).toLocaleString()}  ${summary?.lastPromptPreview || ""}`)
+      }
+    })
+
+  return cmd
+}

package/src/commands/skill.mjs

@@ -0,0 +1,63 @@
+import { Command } from "commander"
+import { ensureDefaultSkillPack } from "../skill/registry.mjs"
+import { userRootDir } from "../storage/paths.mjs"
+
+function formatSummary(scopeResults) {
+  const lines = []
+  for (const item of scopeResults) {
+    const created = item.created.join(", ")
+    const skipped = item.skipped.join(", ")
+    if (created.length) {
+      lines.push(`[${item.scope}] created: ${created}`)
+    }
+    if (skipped.length) {
+      lines.push(`[${item.scope}] already exists: ${skipped}`)
+    }
+  }
+  return lines
+}
+
+export function createSkillCommand() {
+  const cmd = new Command("skill").description("manage kkcode skills")
+
+  cmd
+    .command("init")
+    .description("initialize built-in skill packs")
+    .option("--project", "initialize project scope .kkcode/skills")
+    .option("--global", "initialize global scope (KKCODE_HOME)/skills")
+    .option("--all", "initialize both project and global scope")
+    .option("--force", "overwrite existing files")
+    .option("--json", "print structured output", false)
+    .action(async (options) => {
+      const cwd = process.cwd()
+      const includeProject = options.all || options.project || (!options.global && !options.project)
+      const includeGlobal = options.all || options.global || (!options.global && !options.project)
+
+      const results = await ensureDefaultSkillPack({
+        cwd,
+        force: options.force || false,
+        includeProject,
+        includeGlobal
+      })
+
+      if (options.json) {
+        console.log(JSON.stringify({ ok: true, cwd, includeProject, includeGlobal, results }, null, 2))
+        return
+      }
+
+      console.log("skill init summary:")
+      for (const line of formatSummary(results)) {
+        console.log(`- ${line}`)
+      }
+      if (!results.length) {
+        console.log("- no target directories selected")
+      }
+      console.log("tip:")
+      const globalHint = userRootDir()
+      console.log("  kkcode skill init --project   # initialize .kkcode/skills")
+      console.log(`  kkcode skill init --global    # initialize ${globalHint}/skills`)
+      console.log("  kkcode skill init            # initialize both")
+    })
+
+  return cmd
+}

package/src/commands/theme.mjs

@@ -71,7 +71,7 @@ export function createThemeCommand() {
       printContextWarnings(ctx)
       const theme = ctx.themeState.theme
       const config = ctx.configState.config
-      const modes = ["ask", "plan", "agent", "longagent"]
+      const modes = ["assistant", "plan", "agent", "longagent"]
       for (const mode of modes) {
         const line = renderStatusBar({
           mode,

package/src/commands/update.mjs

@@ -0,0 +1,32 @@
+import { Command } from "commander"
+import { loadConfig } from "../config/load-config.mjs"
+import { PACKAGE_VERSION } from "../version.mjs"
+import { checkForUpdate, installUpdate, updateMessage } from "../update/checker.mjs"
+
+export function createUpdateCommand() {
+  return new Command("update")
+    .description("check for and install kkcode updates")
+    .option("--check", "only check for updates", false)
+    .option("--install", "install the selected update", false)
+    .option("--channel <channel>", "npm dist-tag to follow", null)
+    .option("--json", "print structured result", false)
+    .action(async (options) => {
+      const state = await loadConfig(process.cwd())
+      const config = { ...state.config, update: { ...(state.config.update || {}) } }
+      if (options.channel) config.update.channel = options.channel
+      const result = await checkForUpdate(config, { force: true, currentVersion: PACKAGE_VERSION })
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2))
+      } else if (result.hasUpdate) {
+        console.log(updateMessage(result))
+      } else {
+        console.log(`kkcode is up to date (${result.currentVersion}) on ${result.channel}`)
+      }
+
+      if (options.check || !options.install) return
+      if (!result.hasUpdate) return
+      const installed = await installUpdate(config, { channel: result.channel })
+      if (!installed.ok) throw new Error(`update install failed: ${installed.error}`)
+      console.log(`installed kkcode ${result.latestVersion}; restart your shell or kkcode session if needed`)
+    })
+}