kc-beta 0.3.2 → 0.5.4

package/src/agent/version-manager.js

@@ -1,130 +1,39 @@
-import fs from "node:fs";
-import path from "node:path";
+/**
+ * Trace ID utility.
+ *
+ * As of v0.4.0 (Block 11), real version history is kept by git
+ * (per-session repo, auto-committed by Workspace.autoCommit). This module
+ * is now just a stable place for trace ID generation, used by tools that
+ * need to cross-reference a write or a result with the event log.
+ *
+ * The legacy versions.json manifest in pre-v0.4.0 workspaces is left
+ * untouched — nothing reads it any more, but old data is preserved.
+ */
 
-const VERSIONED_DIRS = new Set(["workflows", "rule_skills", "rules"]);
-const VERSIONED_EXTS = new Set([".py", ".json", ".md", ".txt"]);
+/**
+ * Generate a trace ID like "20260417_114203_R001_workflow_result".
+ * @param {string} ruleId
+ * @param {string} [label]
+ * @returns {string}
+ */
+export function generateTraceId(ruleId, label = "") {
+  const now = new Date().toISOString().replace(/[-:T]/g, (m) =>
+    m === "T" ? "_" : ""
+  ).slice(0, 15);
+  const suffix = label ? `_${label}` : "";
+  return `${now}_${ruleId}${suffix}`;
+}
 
 /**
- * Structural component: every write to versioned directories gets tracked.
- * - Immutable version copies tracked in manifest
- * - Manifest at versions.json: tracks lineage, timestamps, change reasons
- * - Trace ID generation: {timestamp}_{rule_id}_{version}
- * Cannot be bypassed — hooks into WorkspaceFileTool.
+ * Back-compat shell. The class is retained so existing constructors
+ * that take a VersionManager don't break, but it carries no state.
  */
 export class VersionManager {
-  /**
-   * @param {string} workspacePath
-   */
-  constructor(workspacePath) {
-    this._workspace = workspacePath;
-    this._manifestPath = path.join(workspacePath, "versions.json");
-    this._manifest = this._loadManifest();
-  }
-
-  _loadManifest() {
-    if (fs.existsSync(this._manifestPath)) {
-      try {
-        return JSON.parse(fs.readFileSync(this._manifestPath, "utf-8"));
-      } catch {
-        // fall through
-      }
-    }
-    return { version: "0.1.0", entries: [] };
-  }
-
-  _saveManifest() {
-    fs.writeFileSync(
-      this._manifestPath,
-      JSON.stringify(this._manifest, null, 2),
-      "utf-8",
-    );
-  }
-
-  /**
-   * Check if a path falls within versioned directories.
-   * @param {string} relPath
-   * @returns {boolean}
-   */
-  shouldVersion(relPath) {
-    const parts = relPath.split(path.sep);
-    if (parts.length === 0) return false;
-    const topDir = parts[0];
-    const ext = path.extname(relPath);
-    return VERSIONED_DIRS.has(topDir) && VERSIONED_EXTS.has(ext);
-  }
-
-  /**
-   * Called on file write. Returns trace ID if versioned, null otherwise.
-   * @param {string} relPath
-   * @param {string} content
-   * @returns {string|null}
-   */
-  onWrite(relPath, content) {
-    if (!this.shouldVersion(relPath)) return null;
-
-    const version = this._nextVersion(relPath);
-    const now = new Date().toISOString().replace(/[-:T]/g, (m) =>
-      m === "T" ? "_" : ""
-    ).slice(0, 15);
-
-    // Extract rule_id from path if possible (e.g., rule_skills/R001/SKILL.md → R001)
-    const parts = relPath.split(path.sep);
-    const ruleId = parts.length > 1 ? parts[1] : "global";
-
-    const traceId = `${now}_${ruleId}_v${version}`;
-
-    const entry = {
-      file: relPath,
-      version,
-      trace_id: traceId,
-      timestamp: new Date().toISOString(),
-      rule_id: ruleId,
-      size_chars: content.length,
-    };
-
-    this._manifest.entries.push(entry);
-    this._saveManifest();
-
-    return traceId;
-  }
-
-  _nextVersion(relPath) {
-    const existing = this._manifest.entries
-      .filter((e) => e.file === relPath)
-      .map((e) => e.version);
-    return Math.max(0, ...existing) + 1;
-  }
-
-  /**
-   * Get all version entries for a file.
-   * @param {string} relPath
-   * @returns {Array<object>}
-   */
-  getVersions(relPath) {
-    return this._manifest.entries.filter((e) => e.file === relPath);
-  }
-
-  /**
-   * Get the most recent version entry for a file.
-   * @param {string} relPath
-   * @returns {object|null}
-   */
-  latestVersion(relPath) {
-    const versions = this.getVersions(relPath);
-    return versions.length > 0 ? versions[versions.length - 1] : null;
+  constructor(_workspacePath) {
+    // No-op. Workspace path is no longer needed.
   }
 
-  /**
-   * Generate a standalone trace ID for results, QC records, etc.
-   * @param {string} ruleId
-   * @param {string} [label]
-   * @returns {string}
-   */
   generateTraceId(ruleId, label = "") {
-    const now = new Date().toISOString().replace(/[-:T]/g, (m) =>
-      m === "T" ? "_" : ""
-    ).slice(0, 15);
-    const suffix = label ? `_${label}` : "";
-    return `${now}_${ruleId}${suffix}`;
+    return generateTraceId(ruleId, label);
   }
 }

package/src/agent/workspace.js

@@ -1,24 +1,41 @@
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
+import { execFileSync, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { generateTraceId } from "./version-manager.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const GITIGNORE_TEMPLATE = path.resolve(__dirname, "../../template/workspace.gitignore");
 
 /**
  * Per-session workspace directory with path traversal protection.
  * Each agent session gets its own directory under the workspace root.
  * All file operations by tools must go through resolvePath().
+ *
+ * As of v0.4.0 (Block 11): the workspace is also a git repo. Writes to
+ * non-gitignored paths are auto-committed via autoCommit() so KC has a
+ * real version history of its outputs.
  */
 export class Workspace {
   /**
    * @param {string} root - Workspace root directory
    * @param {string} [sessionId] - Session identifier (auto-generated if omitted)
    * @param {string} [projectDir] - User's project directory (CWD at launch)
+   * @param {object} [opts]
+   * @param {boolean} [opts.gitAutoCommit=true] - If false, skip git init / auto-commit
    */
-  constructor(root, sessionId, projectDir) {
+  constructor(root, sessionId, projectDir, opts = {}) {
     this.root = path.resolve(root);
     this.sessionId = sessionId || crypto.randomUUID().replace(/-/g, "").slice(0, 12);
     this.path = path.resolve(this.root, this.sessionId);
     this.projectDir = projectDir ? path.resolve(projectDir) : null;
+    this._currentPhase = "bootstrap";
     fs.mkdirSync(this.path, { recursive: true });
+
+    this._gitAutoCommitEnabled = opts.gitAutoCommit !== false;
+    this._gitAvailable = this._gitAutoCommitEnabled && Workspace.isGitInstalled();
+    if (this._gitAvailable) this._initGitRepo();
   }
 
   /** @returns {string} Current workspace directory */
@@ -26,6 +43,16 @@ export class Workspace {
     return this.path;
   }
 
+  /** @returns {boolean} Whether auto-commit is wired up for this session */
+  get gitAvailable() {
+    return this._gitAvailable;
+  }
+
+  /** Update the current phase (used in auto-commit messages). */
+  setPhase(phase) {
+    if (phase) this._currentPhase = phase;
+  }
+
   /**
    * Resolve a user-supplied relative path against the workspace.
    * Rejects absolute paths and any path that escapes the workspace via .. or symlinks.
@@ -66,23 +93,62 @@ export class Workspace {
   }
 
   /**
-   * Rename the workspace folder. Returns the new sessionId.
+   * Auto-commit a workspace write. Silently no-ops if the path is gitignored,
+   * if there's nothing to commit, or if git isn't available. Returns the trace
+   * ID generated for this write (always returned, even if no commit happened,
+   * so callers can cross-reference with the event log).
+   *
+   * @param {string} relPath - workspace-relative path that was just written
+   * @param {string} [opLabel="update"] - short verb for the commit message
+   * @returns {string} trace id
+   */
+  autoCommit(relPath, opLabel = "update") {
+    const ruleId = this._extractRuleId(relPath);
+    const traceId = generateTraceId(ruleId, opLabel);
+
+    if (!this._gitAvailable) return traceId;
+
+    try {
+      const r = spawnSync("git", ["add", "--", relPath], {
+        cwd: this.path,
+        stdio: "ignore",
+      });
+      if (r.status !== 0) return traceId; // gitignored or other add error — skip commit
+      const msg = `[${this._currentPhase}] ${opLabel} ${relPath} [trace:${traceId}]`;
+      spawnSync("git", ["commit", "-m", msg, "--allow-empty-message"], {
+        cwd: this.path,
+        stdio: "ignore",
+      });
+      // Status doesn't matter — "nothing to commit" is fine.
+    } catch {
+      // Never let a git failure break a workspace write.
+    }
+    return traceId;
+  }
+
+  /**
+   * Rename the workspace folder. Returns `{ sessionId, oldCwd, newCwd }` so
+   * callers can cascade the new path to subsystems that captured cwd at
+   * construction (Bug 3).
    * @param {string} newName
-   * @returns {string}
+   * @returns {{sessionId: string, oldCwd: string, newCwd: string, changed: boolean}}
    */
   rename(newName) {
     newName = newName.trim().replace(/ /g, "_").replace(/\//g, "_");
     if (!newName) throw new Error("Name cannot be empty");
     const newPath = path.join(this.root, newName);
+    const oldCwd = this.path;
     if (fs.existsSync(newPath) && path.resolve(newPath) !== path.resolve(this.path)) {
       throw new Error(`Session '${newName}' already exists`);
     }
+    let changed = false;
     if (path.resolve(newPath) !== path.resolve(this.path)) {
       fs.renameSync(this.path, newPath);
       this.path = path.resolve(newPath);
       this.sessionId = newName;
+      changed = true;
     }
-    return this.sessionId;
+    return { sessionId: this.sessionId, oldCwd, newCwd: this.path, changed };
   }
 
   /**
@@ -102,4 +168,61 @@ export class Workspace {
     }
     return sessions;
   }
+
+  /** Probe whether the `git` executable is on PATH. Cached per process. */
+  static isGitInstalled() {
+    if (Workspace._gitProbeCache !== undefined) return Workspace._gitProbeCache;
+    try {
+      execFileSync("git", ["--version"], { stdio: "ignore" });
+      Workspace._gitProbeCache = true;
+    } catch {
+      Workspace._gitProbeCache = false;
+    }
+    return Workspace._gitProbeCache;
+  }
+
+  // --- private helpers ---
+
+  _initGitRepo() {
+    const gitDir = path.join(this.path, ".git");
+    const gitignorePath = path.join(this.path, ".gitignore");
+    const isFresh = !fs.existsSync(gitDir);
+
+    if (isFresh) {
+      try {
+        spawnSync("git", ["init", "--initial-branch=main"], { cwd: this.path, stdio: "ignore" });
+        // --initial-branch isn't supported on older git; fall back silently
+        if (!fs.existsSync(gitDir)) {
+          spawnSync("git", ["init"], { cwd: this.path, stdio: "ignore" });
+        }
+        // Local identity so commits don't depend on user's global config
+        spawnSync("git", ["config", "user.name", "kc-agent"], { cwd: this.path, stdio: "ignore" });
+        spawnSync("git", ["config", "user.email", "agent@kc.local"], { cwd: this.path, stdio: "ignore" });
+      } catch {
+        this._gitAvailable = false;
+        return;
+      }
+    }
+
+    // Always ensure .gitignore is present (template may have evolved)
+    if (!fs.existsSync(gitignorePath) && fs.existsSync(GITIGNORE_TEMPLATE)) {
+      fs.copyFileSync(GITIGNORE_TEMPLATE, gitignorePath);
+    }
+
+    if (isFresh) {
+      // Initial commit — captures whatever's already in the dir (for migrated workspaces)
+      spawnSync("git", ["add", "-A"], { cwd: this.path, stdio: "ignore" });
+      const msg = fs.existsSync(path.join(this.path, "AGENT.md"))
+        ? `Migrated session ${this.sessionId} to git-tracked workspace`
+        : `Initialized session ${this.sessionId}`;
+      spawnSync("git", ["commit", "--allow-empty", "-m", msg], { cwd: this.path, stdio: "ignore" });
+    }
+  }
+
+  /** Extract rule ID from a path like rule_skills/R001/SKILL.md → "R001". */
+  _extractRuleId(relPath) {
+    const parts = relPath.split(path.sep);
+    if (parts.length >= 2 && /^R\d+/i.test(parts[1])) return parts[1];
+    return "global";
+  }
 }

package/src/cli/components.js

@@ -42,12 +42,20 @@ export function StatusBar({ sessionId, phase, contextTokens, contextLimit }) {
     ? `${(contextLimit / 1000).toFixed(0)}k`
     : `${contextLimit || 0}`;
 
+  // Soft-threshold hint — shows up before auto-windowing kicks in at ~70%
+  // so users know they can run /compact to reduce context more aggressively
+  // than windowing does. Red hint at 80%+ means it's time to compact NOW.
+  const compactHint = pct >= 80 ? "  · 💾 /compact"
+                     : pct >= 60 ? "  · 💾 建议 /compact"
+                     : "";
+
   return h(Box, { marginTop: 0 },
     h(Text, { dimColor: true }, "  ⏵⏵  KC Agent CLI "),
     h(Text, { dimColor: true }, sessionId ? `[${sessionId}]` : ""),
     phase ? h(Text, { color: "cyan" }, ` ${phase.toUpperCase()}`) : null,
     h(Text, { color: "green" }, "  ●  "),
     h(Text, { color: ctxColor }, `CTX: ${ctxLabel}/${limitLabel} (${pct}%)`),
+    compactHint ? h(Text, { color: ctxColor }, compactHint) : null,
     h(Text, { dimColor: true }, `  · ${LENAT_QUOTE}`),
   );
 }
@@ -88,7 +96,7 @@ export function TaskDashboard({ tasks, progress }) {
 
 // --- Welcome banner ---
 
-export function WelcomeBanner({ projectDir } = {}) {
+export function WelcomeBanner({ projectDir, pendingInputCount = 0 } = {}) {
   return h(Box, { flexDirection: "column", marginBottom: 1, borderStyle: "round", borderColor: "gray", paddingLeft: 1, paddingRight: 1 },
     h(Box, null,
       h(Text, { bold: true }, "KC AGENT CLI"),
@@ -102,6 +110,9 @@ export function WelcomeBanner({ projectDir } = {}) {
           h(Text, { color: "yellow", dimColor: true }, "KC has full read/write access to this directory. We recommend backing up important files."),
         )
       : null,
+    pendingInputCount > 0
+      ? h(Text, { color: "cyan" }, `📥 ${pendingInputCount} new file(s) pending in input/ — run /schedule for details`)
+      : null,
     h(Text, null, ""),
     h(Text, { dimColor: true }, "Product of Memium / kitchen-engineer42"),
   );
@@ -109,29 +120,74 @@ export function WelcomeBanner({ projectDir } = {}) {
 
 // --- Tool block ---
 
-export function ToolBlock({ name, input, output, isError, isRunning }) {
+/**
+ * Tool-result block.
+ *
+ * Rendering modes:
+ *   - isRunning       → yellow border, no output (spinner shown elsewhere).
+ *   - isError         → red border, ALWAYS show full output (errors are short + critical).
+ *   - isRecent: true  → green border, show up to ~4 lines + "N lines hidden" footer.
+ *   - isRecent: false → header only (header includes line count + byte count).
+ *
+ * The full output is always on disk in logs/events.jsonl. Keeping the Ink
+ * tree slim is what lets KC handle long sessions without OOM / typing lag.
+ */
+const RECENT_PREVIEW_LINES = 4;
+
+export function ToolBlock({ name, input, output, isError, isRunning, isRecent = true }) {
   const borderColor = isRunning ? "yellow" : isError ? "red" : "green";
+  const outStr = typeof output === "string" ? output : "";
+  const lines = outStr ? outStr.split("\n") : [];
+  const bytes = outStr.length;
+
+  const header = h(Box, null,
+    h(Text, { color: borderColor }, "┃ "),
+    h(Text, { dimColor: true }, name),
+    input ? h(Text, { dimColor: true }, ` ${JSON.stringify(input).slice(0, 120)}`) : null,
+    outStr && !isRunning
+      ? h(Text, { dimColor: true }, `  (${lines.length} 行 / ${bytes} 字节)`)
+      : null,
+  );
+
+  // Errors: always show in full (short + critical).
+  if (isError && outStr) {
+    return h(Box, { flexDirection: "column", marginLeft: 2 },
+      header,
+      h(Box, { flexDirection: "column" },
+        ...lines.map((line, i) =>
+          h(Box, { key: i },
+            h(Text, { color: "red" }, "┃ "),
+            h(Text, { color: "red" }, line),
+          ),
+        ),
+      ),
+    );
+  }
+
+  // Off-screen / not-recent: header only. Full output remains on disk.
+  if (!isRecent || !outStr) {
+    return h(Box, { marginLeft: 2 }, header);
+  }
 
+  // Recent + successful: show preview + truncation footer.
+  const previewLines = lines.slice(0, RECENT_PREVIEW_LINES);
+  const remaining = lines.length - previewLines.length;
   return h(Box, { flexDirection: "column", marginLeft: 2 },
-    h(Box, null,
-      h(Text, { color: borderColor }, "┃ "),
-      h(Text, { dimColor: true }, name),
-      input ? h(Text, { dimColor: true }, ` ${JSON.stringify(input)}`) : null,
-    ),
-    output ? h(Box, { flexDirection: "column" },
-      ...output.split("\n").slice(0, 20).map((line, i) =>
+    header,
+    h(Box, { flexDirection: "column" },
+      ...previewLines.map((line, i) =>
         h(Box, { key: i },
           h(Text, { color: borderColor }, "┃ "),
           h(Text, null, line),
         ),
       ),
-      output.split("\n").length > 20
+      remaining > 0
         ? h(Box, null,
             h(Text, { color: borderColor }, "┃ "),
-            h(Text, { dimColor: true }, `... ${output.split("\n").length - 20} more lines`),
+            h(Text, { dimColor: true }, `… ${remaining} 行已省略（在 logs/events.jsonl 中完整保留）`),
           )
         : null,
-    ) : null,
+    ),
   );
 }