@haposoft/cafekit 0.8.16 → 0.9.0

package/src/opencode/plugins/state.ts

@@ -0,0 +1,253 @@
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * OpenCode Plugin — state.ts
+ *
+ * Port of .claude/hooks/state.cjs (partial).
+ *
+ * Behavior:
+ * - On session.created: read .opencode/session-state/latest.md (if fresh)
+ *   and surface it via stderr + banner file so the assistant sees prior
+ *   execution context.
+ * - On tool.execute.after for state-shaping tools (todowrite, task,
+ *   taskcreate, taskupdate): refresh snapshot.
+ * - On session.idle (≈ Claude Stop): persist snapshot + archive.
+ *
+ * Dropped:
+ * - SubagentStop branch (no equivalent in OpenCode).
+ * - Transcript-based todo extraction (OpenCode plugin context lacks
+ *   transcript_path). Snapshot now captures modifiedFiles only.
+ *
+ * Storage: .opencode/session-state/latest.md + archive/.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  copyFileSync,
+  readdirSync,
+  unlinkSync,
+  renameSync,
+  appendFileSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+const PLUGIN_DIR = dirname(fileURLToPath(import.meta.url));
+const EXPIRY_DAYS = 7;
+const MAX_ARCHIVES = 5;
+const STATE_REFRESH_TOOLS = new Set(["todowrite", "task", "taskcreate", "taskupdate"]);
+const STATE_SECTION_START = "<!-- CAFEKIT STATE START -->";
+const STATE_SECTION_END = "<!-- CAFEKIT STATE END -->";
+
+interface SnapshotData {
+  timestamp: string;
+  branch: string;
+  modifiedFiles: string[];
+}
+
+function stateDir(cwd: string): string | null {
+  try {
+    const dir = join(cwd, ".opencode", "session-state");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    return dir;
+  } catch {
+    return null;
+  }
+}
+
+function loadLatest(dir: string): string | null {
+  try {
+    const file = join(dir, "latest.md");
+    if (!existsSync(file)) return null;
+    const text = readFileSync(file, "utf8");
+    const match = text.match(/<!-- Generated: (.+?) -->/);
+    if (match) {
+      const generatedAt = new Date(match[1]).getTime();
+      if (Number.isNaN(generatedAt)) return null;
+      if (Date.now() - generatedAt > EXPIRY_DAYS * 24 * 60 * 60 * 1000) return null;
+    }
+    return text;
+  } catch {
+    return null;
+  }
+}
+
+function writeAtomic(filePath: string, content: string): void {
+  const tempFile = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  writeFileSync(tempFile, content);
+  renameSync(tempFile, filePath);
+}
+
+function archive(dir: string): void {
+  try {
+    const latestFile = join(dir, "latest.md");
+    if (!existsSync(latestFile)) return;
+
+    const archiveDir = join(dir, "archive");
+    if (!existsSync(archiveDir)) mkdirSync(archiveDir);
+
+    const now = new Date();
+    const pad = (value: number) => String(value).padStart(2, "0");
+    const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}`;
+
+    copyFileSync(latestFile, join(archiveDir, `${stamp}.md`));
+
+    const files = readdirSync(archiveDir)
+      .filter((file) => file.endsWith(".md"))
+      .sort();
+    while (files.length > MAX_ARCHIVES) {
+      const oldest = files.shift();
+      if (oldest) {
+        try {
+          unlinkSync(join(archiveDir, oldest));
+        } catch {
+          // fail-open
+        }
+      }
+    }
+  } catch {
+    // fail-open
+  }
+}
+
+function extractSnapshot(cwd: string): SnapshotData {
+  const data: SnapshotData = {
+    timestamp: new Date().toISOString(),
+    branch: "",
+    modifiedFiles: [],
+  };
+
+  try {
+    data.branch = execSync("git branch --show-current", {
+      cwd,
+      encoding: "utf8",
+      timeout: 3000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    // fail-open
+  }
+
+  try {
+    const diff = execSync("git diff --name-only HEAD", {
+      cwd,
+      encoding: "utf8",
+      timeout: 3000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (diff) data.modifiedFiles = diff.split("\n").slice(0, 20);
+  } catch {
+    // fail-open
+  }
+
+  return data;
+}
+
+function buildStateContent(data: SnapshotData): string {
+  return [
+    "# Session State",
+    `<!-- Generated: ${data.timestamp} -->`,
+    `<!-- Branch: ${data.branch || "unknown"} -->`,
+    "",
+    "## Key Files Modified",
+    ...(data.modifiedFiles.length
+      ? data.modifiedFiles.map((file) => `- ${file}`)
+      : ["- (No file changes detected)"]),
+    "",
+  ].join("\n");
+}
+
+function writeBannerSection(cwd: string, content: string | null): void {
+  const target = join(cwd, ".opencode", "session-banner.md");
+  const dir = dirname(target);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const existing = existsSync(target) ? readFileSync(target, "utf8") : "";
+  const pattern = new RegExp(`${STATE_SECTION_START}[\\s\\S]*?${STATE_SECTION_END}\\n?`);
+  const cleaned = existing.replace(pattern, "").trimEnd();
+
+  if (!content) {
+    if (cleaned !== existing.trimEnd()) {
+      writeFileSync(target, cleaned ? `${cleaned}\n` : "");
+    }
+    return;
+  }
+
+  const block = [STATE_SECTION_START, content, STATE_SECTION_END].join("\n");
+  const next = cleaned ? `${cleaned}\n\n${block}\n` : `${block}\n`;
+  writeFileSync(target, next);
+}
+
+function persistSnapshot(dir: string, data: SnapshotData, options: { archive?: boolean } = {}): void {
+  const file = join(dir, "latest.md");
+  writeAtomic(file, buildStateContent(data));
+  if (options.archive) archive(dir);
+}
+
+function logCrash(error: unknown): void {
+  try {
+    const logDir = join(PLUGIN_DIR, ".logs");
+    if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+    appendFileSync(
+      join(logDir, "hook-log.jsonl"),
+      JSON.stringify({
+        ts: new Date().toISOString(),
+        hook: "state",
+        status: "crash",
+        error: error instanceof Error ? error.message : String(error),
+      }) + "\n",
+    );
+  } catch {
+    // fail-open
+  }
+}
+
+export const State: Plugin = async ({ directory }) => ({
+  event: async ({ event }) => {
+    try {
+      const dir = stateDir(directory);
+      if (!dir) return;
+
+      if (event.type === "session.created") {
+        const previous = loadLatest(dir);
+        if (previous) {
+          const banner = [
+            "=== Prior Execution Context ===",
+            previous.trim(),
+            "=== End of Prior Context ===",
+          ].join("\n");
+          writeBannerSection(directory, banner);
+          console.error(banner);
+        } else {
+          writeBannerSection(directory, null);
+        }
+        return;
+      }
+
+      if (event.type === "session.idle") {
+        const snapshot = extractSnapshot(directory);
+        persistSnapshot(dir, snapshot, { archive: true });
+        return;
+      }
+    } catch (error) {
+      logCrash(error);
+    }
+  },
+
+  "tool.execute.after": async (input) => {
+    try {
+      if (!STATE_REFRESH_TOOLS.has(input.tool)) return;
+      const dir = stateDir(directory);
+      if (!dir) return;
+      const snapshot = extractSnapshot(directory);
+      persistSnapshot(dir, snapshot);
+    } catch (error) {
+      logCrash(error);
+    }
+  },
+});

package/src/opencode/plugins/usage.ts

@@ -0,0 +1,178 @@
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * OpenCode Plugin — usage.ts
+ *
+ * Port of .claude/hooks/usage.cjs adapted to OpenCode's plugin surface.
+ *
+ * Claude's version polls the Anthropic OAuth API for plan usage so the
+ * statusline can render quota. OpenCode has no statusline injection point
+ * and no OAuth plumbing, so this port instead tracks per-session token
+ * usage by inspecting `message.updated` payloads and writing the rolling
+ * totals to `.opencode/session-state/usage.json` for downstream tooling.
+ *
+ * Disable via .opencode/runtime.json: { "usage": { "enabled": false } }.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN_DIR = dirname(fileURLToPath(import.meta.url));
+
+interface UsageTotals {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  messages: number;
+  lastUpdated: string;
+}
+
+interface UsageFile {
+  sessionId: string;
+  startedAt: string;
+  totals: UsageTotals;
+}
+
+function resolveProjectDir(directory?: string): string {
+  if (directory && existsSync(directory)) return directory;
+  // Plugin installed under <project>/.opencode/plugins/, so go up twice.
+  return dirname(dirname(PLUGIN_DIR));
+}
+
+function readRuntime(cwd: string): Record<string, any> {
+  try {
+    const file = join(cwd, ".opencode", "runtime.json");
+    if (existsSync(file)) {
+      return JSON.parse(readFileSync(file, "utf8"));
+    }
+  } catch {
+    /* fail-open */
+  }
+  return {};
+}
+
+function isEnabled(cwd: string): boolean {
+  const runtime = readRuntime(cwd);
+  return runtime?.usage?.enabled !== false;
+}
+
+function usagePath(cwd: string): string {
+  return join(cwd, ".opencode", "session-state", "usage.json");
+}
+
+function readUsage(file: string): UsageFile | null {
+  try {
+    if (!existsSync(file)) return null;
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeUsage(file: string, payload: UsageFile): void {
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(payload, null, 2));
+  } catch {
+    /* fail-open */
+  }
+}
+
+// Defensive extractor: OpenCode message payloads may expose usage either
+// directly on the message or nested under metadata/usage. Accept both.
+function extractUsage(message: any): {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+} | null {
+  const candidates = [
+    message?.usage,
+    message?.metadata?.usage,
+    message?.tokens,
+    message?.metadata?.tokens,
+  ].filter(Boolean);
+
+  for (const c of candidates) {
+    const input =
+      Number(c.input_tokens ?? c.inputTokens ?? c.prompt_tokens ?? 0) || 0;
+    const output =
+      Number(c.output_tokens ?? c.outputTokens ?? c.completion_tokens ?? 0) ||
+      0;
+    const cacheRead =
+      Number(
+        c.cache_read_input_tokens ??
+          c.cacheReadInputTokens ??
+          c.cache_read_tokens ??
+          0,
+      ) || 0;
+    const cacheWrite =
+      Number(
+        c.cache_creation_input_tokens ??
+          c.cacheCreationInputTokens ??
+          c.cache_write_tokens ??
+          0,
+      ) || 0;
+    if (input || output || cacheRead || cacheWrite) {
+      return { input, output, cacheRead, cacheWrite };
+    }
+  }
+  return null;
+}
+
+export const UsagePlugin: Plugin = async ({ directory }) => {
+  const cwd = resolveProjectDir(directory);
+
+  return {
+    event: async ({ event }) => {
+      if (event.type !== "message.updated") return;
+      if (!isEnabled(cwd)) return;
+
+      const message = (event as any).properties?.info ?? (event as any).properties?.message;
+      if (!message) return;
+
+      const tokens = extractUsage(message);
+      if (!tokens) return;
+
+      const sessionId = message.sessionID ?? message.sessionId ?? "default";
+      const file = usagePath(cwd);
+      const now = new Date().toISOString();
+      const existing = readUsage(file);
+
+      const sameSession = existing && existing.sessionId === sessionId;
+      const totals: UsageTotals = sameSession
+        ? existing!.totals
+        : {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            messages: 0,
+            lastUpdated: now,
+          };
+
+      totals.inputTokens += tokens.input;
+      totals.outputTokens += tokens.output;
+      totals.cacheReadTokens += tokens.cacheRead;
+      totals.cacheWriteTokens += tokens.cacheWrite;
+      totals.messages += 1;
+      totals.lastUpdated = now;
+
+      writeUsage(file, {
+        sessionId,
+        startedAt: sameSession ? existing!.startedAt : now,
+        totals,
+      });
+    },
+  };
+};
+
+export default UsagePlugin;

package/src/antigravity/GEMINI.md

@@ -1,162 +0,0 @@
----
-trigger: always_on
----
-
-# GEMINI.md - Antigravity Kit
-
-> This file defines how the AI behaves in this workspace.
-
----
-
-## CRITICAL: AGENT & SKILL PROTOCOL (START HERE)
-
-> **MANDATORY:** You MUST read the appropriate agent file and its skills BEFORE performing any implementation. This is the highest priority rule.
-
-### 1. Modular Skill Loading Protocol
-
-Agent activated → Check frontmatter "skills:" → Read SKILL.md (INDEX) → Read specific sections.
-
-- **Selective Reading:** DO NOT read ALL files in a skill folder. Read `SKILL.md` first, then only read sections matching the user's request.
-- **Rule Priority:** P0 (GEMINI.md) > P1 (Agent .md) > P2 (SKILL.md). All rules are binding.
-
-### 2. Enforcement Protocol
-
-1. **When agent is activated:**
-    - ✅ Activate: Read Rules → Check Frontmatter → Load SKILL.md → Apply All.
-2. **Forbidden:** Never skip reading agent rules or skill instructions. "Read → Understand → Apply" is mandatory.
-3. **Artifact Ban:** DO NOT create "Implementation Plan" artifacts (sidebar artifacts) unless the user EXPLICITLY asks for them. Use standard markdown files in `docs/` or text responses instead.
-
----
-
-## 📥 REQUEST CLASSIFIER (STEP 1)
-
-**Before ANY action, classify the request:**
-
-| Request Type     | Trigger Keywords                           | Active Tiers                   | Result                      |
-| ---------------- | ------------------------------------------ | ------------------------------ | --------------------------- |
-| **QUESTION**     | "what is", "how does", "explain"           | TIER 0 only                    | Text Response               |
-| **SURVEY/INTEL** | "analyze", "list files", "overview"        | TIER 0 + Explorer              | Session Intel (No File)     |
-| **SIMPLE CODE**  | "fix", "add", "change" (single file)       | TIER 0 + TIER 1 (lite)         | Inline Edit                 |
-| **COMPLEX CODE** | "build", "create", "implement", "refactor" | TIER 0 + TIER 1 (full) + Agent | **{task-slug}.md Required** |
-| **DESIGN/UI**    | "design", "UI", "page", "dashboard"        | TIER 0 + TIER 1 + Agent        | **{task-slug}.md Required** |
-| **SLASH CMD**    | /spec-init, /spec-requirements, /spec-design, /spec-tasks, /spec-status, /code, /test, /review, /docs-init, /docs-update | Command-specific flow | Variable |
-
----
-
-## TIER 0: UNIVERSAL RULES (Always Active)
-
-### 💬 Response Format
-
-All responses must generally follow this structure:
-1. **Explanation**: Brief context/problem/solution.
-2. **Implementation**: Code/Action with clear comments.
-3. **Usage/Caveats**: (If applicable)
-4. **Next Action:** (MANDATORY) Specific proposed next step.
-   - Example: "Use `/spec-init` to start", "Review `docs/PLAN-x.md`", "Run `pytest`".
-
-### 🌐 Language Handling
-
-When user's prompt is NOT in English:
-
-1. **Internally translate** for better comprehension
-2. **Respond in user's language** - match their communication
-3. **Code comments/variables** remain in English
-
-### 🧹 Clean Code (Global Mandatory)
-
-- **Code**: Concise, direct, no over-engineering. Self-documenting.
-- **Testing**: Mandatory. Pyramid (Unit > Int > E2E) + AAA Pattern.
-- **Performance**: Measure first. Adhere to 2025 standards (Core Web Vitals).
-- **Infra/Safety**: 5-Phase Deployment. Verify secrets security.
-- Concise, direct, solution-focused
-- No verbose explanations
-- No over-commenting
-- No over-engineering
-- **Artifact Control:** DO NOT create "Implementation Plan" artifacts (sidebar artifacts) unless the user EXPLICITLY asks for them. Use standard markdown files in `docs/` or text responses instead.
-- **Self-Documentation:** Every agent is responsible for documenting their own changes in relevant `.md` files.
-
-### 🗺️ System Map Read
-
-**Path Awareness:**
-
-- Skills: `.agent/skills/` (Project)
-- Workflows: `.agent/workflows/` (Project)
-- Models: `.agent/models/` (Project)
-- Specs: `.specs/` (Project)
-
-### 🧠 Read → Understand → Apply
-
-```
-❌ WRONG: Read agent file → Start coding
-✅ CORRECT: Read → Understand WHY → Apply PRINCIPLES → Code
-```
-
-**Before coding, answer:**
-
-1. What is the GOAL of this agent/skill?
-2. What PRINCIPLES must I apply?
-3. How does this DIFFER from generic output?
-
----
-
-## TIER 1: CODE RULES (When Writing Code)
-
-### 🛑 GLOBAL SOCRATIC GATE (TIER 0)
-
-**MANDATORY: Every user request must pass through the Socratic Gate before ANY tool use or implementation.**
-
-| Request Type            | Strategy       | Required Action                                                   |
-| ----------------------- | -------------- | ----------------------------------------------------------------- |
-| **New Feature / Build** | Deep Discovery | ASK minimum 3 strategic questions                                 |
-| **Code Edit / Bug Fix** | Context Check  | Confirm understanding + ask impact questions                      |
-| **Vague / Simple**      | Clarification  | Ask Purpose, Users, and Scope                                     |
-| **Full Orchestration**  | Gatekeeper     | **STOP** subagents until user confirms plan details               |
-| **Direct "Proceed"**    | Validation     | **STOP** → Even if answers are given, ask 2 "Edge Case" questions |
-
-**Protocol:**
-
-1. **Never Assume:** If even 1% is unclear, ASK.
-2. **Handle Spec-heavy Requests:** When user gives a list (Answers 1, 2, 3...), do NOT skip the gate. Instead, ask about **Trade-offs** or **Edge Cases** (e.g., "LocalStorage confirmed, but should we handle data clearing or versioning?") before starting.
-3. **Wait:** Do NOT invoke subagents or write code until the user clears the Gate.
-
----
-
-## 📁 AVAILABLE WORKFLOWS
-
-### Spec-Driven Development
-
-| Command | Mô tả |
-|---------|-------|
-| `/spec-init <mô tả>` | Khởi tạo spec mới từ ý tưởng |
-| `/spec-requirements <feature>` | Sinh requirements (EARS format) |
-| `/spec-design <feature>` | Sinh design doc + research |
-| `/spec-tasks <feature>` | Sinh task list |
-| `/code <feature>` | Implement task từ spec và chuyển qua test/review |
-| `/spec-status <feature>` | Xem trạng thái hiện tại |
-
-### Documentation
-
-| Command | Mô tả |
-|---------|-------|
-| `/docs-init` | Initialize project documentation |
-| `/docs-update` | Update existing documentation |
-
-**Usage:**
-- Read `.agent/skills/specs/SKILL.md` for detailed workflow information
-- Each workflow has its own file in `.agent/workflows/` with specific instructions
-
----
-
-## 📁 QUICK REFERENCE
-
-### Skills
-
-- **specs**: Complete SDD workflow from idea to implementation
-
-### Workflows Location
-
-- Workflows: `.agent/workflows/`
-- Skill definitions: `.agent/skills/`
-- Spec data: `.specs/<feature-name>/`
-
----

package/src/antigravity/workflows/code.md

@@ -1,16 +0,0 @@
----
-description: Implement approved work from specification tasks and then hand off to test and review.
-allowed-tools: Read, Glob, Grep, Edit, Write, Bash
-argument-hint: <feature-name>
----
-
-# /code - Implement from spec tasks
-
-Use this workflow after `/spec-tasks`.
-
-1. Read `.specs/$ARGUMENTS/tasks.md` and identify the next pending task.
-2. Implement only that task following project standards.
-3. Run `/test`.
-4. Run `/review`.
-
-Preferred flow: `/spec-init` - `/spec-requirements` - `/spec-design` - `/spec-tasks` - `/code` - `/test` - `/review`