@opentil/cli 1.11.0

package/dist/index.js

@@ -0,0 +1,620 @@
+#!/usr/bin/env node
+
+// src/commands/install.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/agents/registry.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/utils.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, rmSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var home = homedir();
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(path, data) {
+  ensureDir(dirname(path));
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function readTextFile(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function writeTextFile(path, content) {
+  ensureDir(dirname(path));
+  writeFileSync(path, content, "utf-8");
+}
+function removeFile(path) {
+  try {
+    rmSync(path, { force: true });
+  } catch {
+  }
+}
+function removeDir(path) {
+  try {
+    rmSync(path, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/agents/registry.ts
+var agents = {
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    detect: () => existsSync2(join2(home, ".claude")),
+    globalSkillDir: join2(home, ".claude", "skills"),
+    extras: ["hooks", "claude-md"]
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    detect: () => existsSync2(join2(home, ".cursor")),
+    globalSkillDir: join2(home, ".cursor", "skills"),
+    extras: ["cursor-rules"]
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    detect: () => existsSync2(join2(home, ".codex")),
+    globalSkillDir: join2(home, ".agents", "skills"),
+    extras: []
+  },
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    detect: () => existsSync2(join2(home, ".config", "opencode")),
+    globalSkillDir: join2(home, ".agents", "skills"),
+    extras: []
+  }
+};
+
+// src/agents/detect.ts
+function detectAgents() {
+  return Object.entries(agents).map(([id, config]) => ({
+    id,
+    config,
+    installed: config.detect()
+  }));
+}
+
+// src/skill-content.ts
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync3 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+function resolveSkillDir() {
+  const candidates = [
+    // npm package: dist/../templates/skill/ (prebuild copies skills/til/ here)
+    join3(__dirname, "..", "templates", "skill"),
+    // dev fallback: cli/src/../../skills/til/
+    join3(__dirname, "..", "..", "skills", "til")
+  ];
+  for (const dir of candidates) {
+    if (existsSync3(dir)) return dir;
+  }
+  throw new Error("Could not find skill content. Please report this issue.");
+}
+function installSkillFiles(targetDir) {
+  const skillDir = resolveSkillDir();
+  const skillMd = readFileSync2(join3(skillDir, "SKILL.md"), "utf-8");
+  ensureDir(targetDir);
+  writeTextFile(join3(targetDir, "SKILL.md"), skillMd);
+  const refsDir = join3(skillDir, "references");
+  if (existsSync3(refsDir)) {
+    const targetRefsDir = join3(targetDir, "references");
+    ensureDir(targetRefsDir);
+    for (const file of readdirSync(refsDir)) {
+      const content = readFileSync2(join3(refsDir, file), "utf-8");
+      writeTextFile(join3(targetRefsDir, file), content);
+    }
+  }
+}
+
+// src/agents/claude-code.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+function resolveTemplate(name) {
+  const candidates = [
+    join4(__dirname2, "..", "..", "templates", name),
+    // from cli/src or cli/dist
+    join4(__dirname2, "..", "templates", name)
+    // fallback
+  ];
+  for (const p5 of candidates) {
+    if (existsSync4(p5)) return readFileSync3(p5, "utf-8");
+  }
+  throw new Error(`Template not found: ${name}`);
+}
+function installClaudeCodeExtras(extras) {
+  if (extras.includes("hooks")) {
+    installHooks();
+  }
+  if (extras.includes("claude-md")) {
+    installClaudeMdSection();
+  }
+}
+function uninstallClaudeCodeExtras() {
+  uninstallHooks();
+  uninstallClaudeMdSection();
+}
+function installHooks() {
+  const hooksPath = join4(home, ".claude", "hooks.json");
+  const templateContent = resolveTemplate("hooks.json");
+  const template = JSON.parse(templateContent);
+  let existing = readJsonFile(hooksPath);
+  if (!existing) {
+    existing = { hooks: {} };
+  }
+  if (!existing.hooks) {
+    existing.hooks = {};
+  }
+  for (const [event, entries] of Object.entries(template.hooks)) {
+    if (!existing.hooks[event]) {
+      existing.hooks[event] = [];
+    }
+    for (const entry of entries) {
+      const alreadyExists = existing.hooks[event].some(
+        (e) => {
+          if (entry.matcher) return e.matcher === entry.matcher;
+          const entryCmd = entry.hooks?.map((h) => h.command).join("|");
+          const existCmd = e.hooks?.map((h) => h.command).join("|");
+          return entryCmd === existCmd;
+        }
+      );
+      if (!alreadyExists) {
+        existing.hooks[event].push(entry);
+      }
+    }
+  }
+  writeJsonFile(hooksPath, existing);
+}
+function uninstallHooks() {
+  const hooksPath = join4(home, ".claude", "hooks.json");
+  const existing = readJsonFile(hooksPath);
+  if (!existing?.hooks) return;
+  const templateContent = resolveTemplate("hooks.json");
+  const template = JSON.parse(templateContent);
+  for (const [event, templateEntries] of Object.entries(template.hooks)) {
+    if (!existing.hooks[event]) continue;
+    const tEntries = templateEntries;
+    existing.hooks[event] = existing.hooks[event].filter(
+      (e) => !tEntries.some((t) => {
+        if (t.matcher) return e.matcher === t.matcher;
+        const tCmd = t.hooks?.map((h) => h.command).join("|");
+        const eCmd = e.hooks?.map((h) => h.command).join("|");
+        return tCmd === eCmd;
+      })
+    );
+    if (existing.hooks[event].length === 0) {
+      delete existing.hooks[event];
+    }
+  }
+  if (Object.keys(existing.hooks).length === 0) {
+    removeFile(hooksPath);
+  } else {
+    writeJsonFile(hooksPath, existing);
+  }
+}
+var OPENTIL_START = "<!-- opentil:start -->";
+var OPENTIL_END = "<!-- opentil:end -->";
+function installClaudeMdSection() {
+  const claudeMdPath = join4(home, ".claude", "CLAUDE.md");
+  const section = resolveTemplate("claude-md-section.md");
+  let content = readTextFile(claudeMdPath);
+  if (content === null) {
+    writeTextFile(claudeMdPath, section);
+    return;
+  }
+  if (content.includes(OPENTIL_START)) {
+    const startIdx = content.indexOf(OPENTIL_START);
+    const endIdx = content.indexOf(OPENTIL_END);
+    if (endIdx !== -1) {
+      content = content.slice(0, startIdx) + section + content.slice(endIdx + OPENTIL_END.length);
+      writeTextFile(claudeMdPath, content);
+    }
+    return;
+  }
+  const separator = content.endsWith("\n") ? "\n" : "\n\n";
+  writeTextFile(claudeMdPath, content + separator + section);
+}
+function uninstallClaudeMdSection() {
+  const claudeMdPath = join4(home, ".claude", "CLAUDE.md");
+  const content = readTextFile(claudeMdPath);
+  if (!content || !content.includes(OPENTIL_START)) return;
+  const startIdx = content.indexOf(OPENTIL_START);
+  const endIdx = content.indexOf(OPENTIL_END);
+  if (endIdx === -1) return;
+  let before = content.slice(0, startIdx);
+  let after = content.slice(endIdx + OPENTIL_END.length);
+  before = before.replace(/\n\n$/, "\n");
+  after = after.replace(/^\n\n/, "\n");
+  const result = (before + after).trim();
+  if (result.length === 0) {
+    removeFile(claudeMdPath);
+  } else {
+    writeTextFile(claudeMdPath, result + "\n");
+  }
+}
+
+// src/agents/cursor.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = dirname4(fileURLToPath3(import.meta.url));
+function resolveTemplate2(name) {
+  const candidates = [
+    join5(__dirname3, "..", "..", "templates", name),
+    join5(__dirname3, "..", "templates", name)
+  ];
+  for (const p5 of candidates) {
+    if (existsSync5(p5)) return readFileSync4(p5, "utf-8");
+  }
+  throw new Error(`Template not found: ${name}`);
+}
+function installCursorExtras(extras) {
+  if (extras.includes("cursor-rules")) {
+    installCursorRule();
+  }
+}
+function uninstallCursorExtras() {
+  uninstallCursorRule();
+}
+function installCursorRule() {
+  const rulesDir = join5(home, ".cursor", "rules");
+  ensureDir(rulesDir);
+  const rule = resolveTemplate2("cursor-rule.md");
+  writeTextFile(join5(rulesDir, "til.md"), rule);
+}
+function uninstallCursorRule() {
+  removeFile(join5(home, ".cursor", "rules", "til.md"));
+}
+
+// src/manifest.ts
+import { join as join6 } from "path";
+var MANIFEST_PATH = join6(home, ".opentil", "manifest.json");
+function readManifest() {
+  return readJsonFile(MANIFEST_PATH);
+}
+function writeManifest(manifest) {
+  writeJsonFile(MANIFEST_PATH, manifest);
+}
+function removeManifest() {
+  removeFile(MANIFEST_PATH);
+}
+function createManifest(version) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version,
+    installedAt: now,
+    updatedAt: now,
+    agents: {}
+  };
+}
+function updateManifest(manifest, version) {
+  return {
+    ...manifest,
+    version,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/commands/install.ts
+import { join as join8 } from "path";
+
+// src/version.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __dirname4 = dirname5(fileURLToPath4(import.meta.url));
+function getVersion() {
+  const candidates = [
+    join7(__dirname4, "..", "..", "package.json"),
+    // from cli/src or cli/dist
+    join7(__dirname4, "..", "package.json")
+    // fallback
+  ];
+  for (const p5 of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync5(p5, "utf-8"));
+      if (pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+
+// src/commands/install.ts
+var EXTRA_LABELS = {
+  hooks: "Hooks (auto-detection reminders)",
+  "claude-md": "CLAUDE.md (TIL auto-detection section)",
+  "cursor-rules": "Cursor Rules (TIL suggestion rule)"
+};
+async function install() {
+  const version = getVersion();
+  p.intro(`${pc.bgCyan(pc.black(" OpenTIL "))} v${version}`);
+  const detected = detectAgents();
+  const installedAgents = detected.filter((a) => a.installed);
+  if (installedAgents.length === 0) {
+    p.log.warn("No supported AI agents detected.");
+    p.log.info("Supported agents: " + Object.values(agents).map((a) => a.displayName).join(", "));
+    p.log.info("Install an agent first, then re-run this installer.");
+    p.outro("Done");
+    return;
+  }
+  p.log.info(
+    `Detected: ${installedAgents.map((a) => pc.green(a.config.displayName)).join(", ")}`
+  );
+  const existingManifest = readManifest();
+  const agentSelection = await p.multiselect({
+    message: "Which agents should have the TIL skill?",
+    options: installedAgents.map((a) => ({
+      value: a.id,
+      label: a.config.displayName,
+      hint: a.config.extras.length > 0 ? `+ ${a.config.extras.map((e) => EXTRA_LABELS[e].split(" (")[0]).join(", ")}` : void 0
+    })),
+    initialValues: existingManifest ? Object.keys(existingManifest.agents) : installedAgents.map((a) => a.id),
+    required: true
+  });
+  if (p.isCancel(agentSelection)) {
+    p.cancel("Installation cancelled.");
+    process.exit(0);
+  }
+  const selectedAgentIds = agentSelection;
+  const agentExtras = {};
+  for (const agentId of selectedAgentIds) {
+    const config = agents[agentId];
+    if (config.extras.length === 0) {
+      agentExtras[agentId] = [];
+      continue;
+    }
+    const existingExtras = existingManifest?.agents[agentId]?.extras ?? config.extras;
+    const extras = await p.multiselect({
+      message: `${config.displayName} extras:`,
+      options: config.extras.map((e) => ({
+        value: e,
+        label: EXTRA_LABELS[e]
+      })),
+      initialValues: existingExtras,
+      required: false
+    });
+    if (p.isCancel(extras)) {
+      p.cancel("Installation cancelled.");
+      process.exit(0);
+    }
+    agentExtras[agentId] = extras;
+  }
+  const s = p.spinner();
+  const manifest = existingManifest ? updateManifest(existingManifest, version) : createManifest(version);
+  manifest.agents = {};
+  const agentsToRemove = existingManifest ? Object.keys(existingManifest.agents).filter((id) => !selectedAgentIds.includes(id)) : [];
+  for (const agentId of agentsToRemove) {
+    const config = agents[agentId];
+    if (!config) continue;
+    s.start(`Removing TIL from ${config.displayName}...`);
+    removeAgentSkill(agentId, config.globalSkillDir);
+    s.stop(`${config.displayName} removed`);
+  }
+  for (const agentId of selectedAgentIds) {
+    const config = agents[agentId];
+    const extras = agentExtras[agentId];
+    s.start(`Installing TIL skill for ${config.displayName}...`);
+    const skillDir = join8(config.globalSkillDir, "til");
+    installSkillFiles(skillDir);
+    if (agentId === "claude-code") {
+      installClaudeCodeExtras(extras);
+    } else if (agentId === "cursor") {
+      installCursorExtras(extras);
+    }
+    manifest.agents[agentId] = {
+      skill: true,
+      extras
+    };
+    const extrasLabel = extras.length > 0 ? ` + ${extras.map((e) => EXTRA_LABELS[e].split(" (")[0]).join(", ")}` : "";
+    s.stop(`${config.displayName}: skill${extrasLabel}`);
+  }
+  writeManifest(manifest);
+  p.note(
+    [
+      `Skill installed for: ${selectedAgentIds.map((id) => agents[id].displayName).join(", ")}`,
+      "",
+      "Next steps:",
+      "  1. Get a token at https://opentil.ai/dashboard/settings/tokens",
+      '  2. Set it: export OPENTIL_TOKEN="til_xxx"',
+      "  3. Use /til in your agent to capture insights!",
+      "",
+      `Re-run ${pc.cyan("npx @opentil/cli")} to modify your setup.`
+    ].join("\n"),
+    "Setup complete"
+  );
+  p.outro("Happy TIL-ing!");
+}
+function removeAgentSkill(agentId, globalSkillDir) {
+  const skillDir = join8(globalSkillDir, "til");
+  removeDir(skillDir);
+  if (agentId === "claude-code") {
+    uninstallClaudeCodeExtras();
+  } else if (agentId === "cursor") {
+    uninstallCursorExtras();
+  }
+}
+
+// src/commands/update.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+async function update() {
+  p2.intro(`${pc2.bgCyan(pc2.black(" OpenTIL "))} update`);
+  p2.log.info(`Current version: v${getVersion()}`);
+  p2.log.info("To update, re-run the installer:");
+  p2.log.info(pc2.cyan("  curl -fsSL til.so/i | bash"));
+  p2.log.info("");
+  p2.log.info("Or with npx:");
+  p2.log.info(pc2.cyan("  npx @opentil/cli@latest"));
+  p2.outro("The installer always uses the latest skill content.");
+}
+
+// src/commands/uninstall.ts
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+import { join as join9 } from "path";
+async function uninstall() {
+  p3.intro(`${pc3.bgCyan(pc3.black(" OpenTIL "))} uninstall`);
+  const manifest = readManifest();
+  if (!manifest) {
+    p3.log.warn("No OpenTIL installation found.");
+    p3.outro("Nothing to do");
+    return;
+  }
+  const agentIds = Object.keys(manifest.agents);
+  p3.log.info(
+    `Currently installed for: ${agentIds.map((id) => agents[id]?.displayName ?? id).join(", ")}`
+  );
+  const confirm2 = await p3.confirm({
+    message: "Remove TIL skill from all agents?"
+  });
+  if (p3.isCancel(confirm2) || !confirm2) {
+    p3.cancel("Uninstall cancelled.");
+    return;
+  }
+  const s = p3.spinner();
+  for (const agentId of agentIds) {
+    const config = agents[agentId];
+    if (!config) continue;
+    s.start(`Removing TIL from ${config.displayName}...`);
+    removeDir(join9(config.globalSkillDir, "til"));
+    if (agentId === "claude-code") {
+      uninstallClaudeCodeExtras();
+    } else if (agentId === "cursor") {
+      uninstallCursorExtras();
+    }
+    s.stop(`${config.displayName}: removed`);
+  }
+  removeManifest();
+  p3.outro("OpenTIL has been uninstalled. See you next time!");
+}
+
+// src/commands/doctor.ts
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+import { existsSync as existsSync6 } from "fs";
+import { join as join10 } from "path";
+async function doctor() {
+  p4.intro(`${pc4.bgCyan(pc4.black(" OpenTIL "))} doctor`);
+  const manifest = readManifest();
+  if (!manifest) {
+    p4.log.warn("No OpenTIL installation found.");
+    p4.log.info(`Run ${pc4.cyan("npx @opentil/cli")} to install.`);
+    p4.outro("Done");
+    return;
+  }
+  p4.log.info(`Installed version: v${manifest.version}`);
+  p4.log.info(`Current CLI version: v${getVersion()}`);
+  const checks = [];
+  for (const [agentId, agentManifest] of Object.entries(manifest.agents)) {
+    const config = agents[agentId];
+    if (!config) {
+      checks.push({ label: `${agentId}: agent config`, ok: false, detail: "Unknown agent" });
+      continue;
+    }
+    checks.push({
+      label: `${config.displayName}: detected`,
+      ok: config.detect(),
+      detail: config.detect() ? void 0 : "Agent not found on system"
+    });
+    const skillMdPath = join10(config.globalSkillDir, "til", "SKILL.md");
+    checks.push({
+      label: `${config.displayName}: SKILL.md`,
+      ok: existsSync6(skillMdPath),
+      detail: existsSync6(skillMdPath) ? skillMdPath : "Missing"
+    });
+    for (const extra of agentManifest.extras) {
+      const result = checkExtra(agentId, extra);
+      checks.push(result);
+    }
+  }
+  const hasToken = !!process.env.OPENTIL_TOKEN;
+  const hasCredentials = existsSync6(join10(home, ".til", "credentials"));
+  checks.push({
+    label: "Token / credentials",
+    ok: hasToken || hasCredentials,
+    detail: hasToken ? "OPENTIL_TOKEN set" : hasCredentials ? "~/.til/credentials found" : "No token found. Set OPENTIL_TOKEN or run /til auth"
+  });
+  let allOk = true;
+  for (const check of checks) {
+    const icon = check.ok ? pc4.green("\u2713") : pc4.red("\u2717");
+    const detail = check.detail ? pc4.dim(` (${check.detail})`) : "";
+    p4.log.info(`  ${icon} ${check.label}${detail}`);
+    if (!check.ok) allOk = false;
+  }
+  if (allOk) {
+    p4.outro(pc4.green("All checks passed!"));
+  } else {
+    p4.outro(pc4.yellow("Some checks failed. Run npx @opentil/cli to fix."));
+  }
+}
+function checkExtra(agentId, extra) {
+  const config = agents[agentId];
+  const label = `${config.displayName}: ${extra}`;
+  switch (extra) {
+    case "hooks": {
+      const hooksPath = join10(home, ".claude", "hooks.json");
+      const hooks = readJsonFile(hooksPath);
+      const hasOpentilHook = hooks?.hooks?.PostToolUse?.some(
+        (h) => h.matcher?.includes("ExitPlanMode")
+      ) || hooks?.hooks?.Stop?.some(
+        (h) => {
+          const entry = h;
+          return entry.hooks?.some((hook) => hook.command?.includes("OpenTIL"));
+        }
+      );
+      return { label, ok: !!hasOpentilHook, detail: hasOpentilHook ? void 0 : "Hook not found in hooks.json" };
+    }
+    case "claude-md": {
+      const claudeMdPath = join10(home, ".claude", "CLAUDE.md");
+      const content = readTextFile(claudeMdPath);
+      const hasSection = content?.includes("<!-- opentil:start -->");
+      return { label, ok: !!hasSection, detail: hasSection ? void 0 : "Section not found in CLAUDE.md" };
+    }
+    case "cursor-rules": {
+      const rulePath = join10(home, ".cursor", "rules", "til.md");
+      return { label, ok: existsSync6(rulePath), detail: existsSync6(rulePath) ? void 0 : "Rule file missing" };
+    }
+    default:
+      return { label, ok: false, detail: `Unknown extra: ${extra}` };
+  }
+}
+
+// src/index.ts
+var command = process.argv[2];
+switch (command) {
+  case "update":
+    update();
+    break;
+  case "uninstall":
+    uninstall();
+    break;
+  case "doctor":
+    doctor();
+    break;
+  default:
+    install();
+    break;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@opentil/cli",
+  "version": "1.11.0",
+  "description": "Universal skill installer for OpenTIL",
+  "type": "module",
+  "bin": {
+    "opentil": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "prebuild": "node scripts/copy-skill.js",
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/opentil/opentil-skills.git",
+    "directory": "cli"
+  },
+  "keywords": [
+    "opentil",
+    "til",
+    "skill",
+    "installer",
+    "claude-code",
+    "cursor",
+    "ai-agent"
+  ]
+}

package/templates/claude-md-section.md

@@ -0,0 +1,5 @@
+<!-- opentil:start -->
+## TIL Auto-Detection
+
+When you notice a genuine insight during development (surprising behavior, non-obvious root cause, clever pattern), proactively suggest capturing it with `/til`. Only suggest once per session unless the user asks.
+<!-- opentil:end -->

package/templates/cursor-rule.md

@@ -0,0 +1,4 @@
+# TIL Skill
+
+When you notice a TIL-worthy insight during development, suggest the user capture it with the /til command.
+See the TIL skill (installed in .cursor/skills/til/) for full command reference.

package/templates/hooks.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo '[OpenTIL] Consider capturing a TIL from this session with /til'"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo '[OpenTIL] If you learned something new, capture it with /til'",
+            "once": true
+          }
+        ]
+      }
+    ]
+  }
+}