teamai-cli 0.16.5 → 0.16.7

package/dist/index.js

@@ -807,119 +807,80 @@ var init_config = __esm({
 });
 
 // src/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  CLAUDE_TO_CURSOR_EVENTS: () => CLAUDE_TO_CURSOR_EVENTS,
+  TEAMAI_HOOK_SUBCOMMANDS: () => TEAMAI_HOOK_SUBCOMMANDS,
+  TEAMAI_LEGACY_HOOK_SUBCOMMANDS: () => TEAMAI_LEGACY_HOOK_SUBCOMMANDS,
+  injectHooks: () => injectHooks,
+  injectHooksToAllTools: () => injectHooksToAllTools,
+  removeHooks: () => removeHooks
+});
 import path6 from "path";
-function getTrackCommand(tool) {
-  return `bash -lc "teamai track --stdin --tool ${tool} 2>/dev/null" || true`;
-}
-function getTrackSlashCommand(tool) {
-  return `bash -lc "teamai track-slash --stdin --tool ${tool} 2>/dev/null" || true`;
-}
-function getDashboardReportCommand(tool) {
-  return `bash -lc "teamai dashboard-report --stdin --tool ${tool} 2>/dev/null" || true`;
-}
-function getAutoRecallCommand(tool) {
-  return `bash -lc "teamai auto-recall --stdin 2>/dev/null" || true`;
-}
-function getContributeCheckCommand(tool) {
-  return `bash -lc "teamai contribute-check --stdin --tool ${tool} 2>/dev/null" || true`;
+function getDispatchCommand(event, tool, matcher) {
+  const matcherArg = matcher && matcher !== "*" ? ` --matcher ${matcher}` : "";
+  return `bash -lc "teamai hook-dispatch ${event} --tool ${tool}${matcherArg} 2>/dev/null" || true`;
 }
 function getClaudeHooks(tool) {
   return [
+    // ─── SessionStart: single dispatcher handles pull + dashboard-report ────
     {
       eventType: "SessionStart",
-      descriptionKeyword: "Auto-pull",
+      descriptionKeyword: "Hook dispatch session-start",
       hook: {
         matcher: "*",
-        hooks: [{ type: "command", command: TEAMAI_PULL_COMMAND }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Auto-pull team resources on session start`
+        hooks: [{ type: "command", command: getDispatchCommand("session-start", tool) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch session-start`
       }
     },
+    // ─── Stop: single dispatcher handles update + contribute-check + dashboard-report ────
     {
       eventType: "Stop",
-      descriptionKeyword: "Auto-update",
+      descriptionKeyword: "Hook dispatch stop",
       hook: {
         matcher: "*",
-        // 10s timeout: npm registry call typically <5s; cap at 10s so a stalled
-        // call cannot delay session shutdown by the default 60s.
-        hooks: [{ type: "command", command: TEAMAI_UPDATE_COMMAND, timeout: 10 }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Auto-update on session end`
+        hooks: [{ type: "command", command: getDispatchCommand("stop", tool) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch stop`
       }
     },
-    // ─── Contribute check (smart threshold hint at session end) ────────
+    // ─── PostToolUse (*): dashboard-report ────
     {
-      eventType: "Stop",
-      descriptionKeyword: "Contribute check",
+      eventType: "PostToolUse",
+      descriptionKeyword: "Hook dispatch post-tool-use wildcard",
       hook: {
         matcher: "*",
-        hooks: [{ type: "command", command: getContributeCheckCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Contribute check on session end`
+        hooks: [{ type: "command", command: getDispatchCommand("post-tool-use", tool) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch post-tool-use wildcard`
       }
     },
+    // ─── PostToolUse (Skill): track ────
     {
       eventType: "PostToolUse",
-      descriptionKeyword: "Track skill",
+      descriptionKeyword: "Hook dispatch post-tool-use Skill",
       hook: {
         matcher: "Skill",
-        hooks: [{ type: "command", command: getTrackCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Track skill usage`
+        hooks: [{ type: "command", command: getDispatchCommand("post-tool-use", tool, "Skill") }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch post-tool-use Skill`
       }
     },
-    {
-      eventType: "UserPromptSubmit",
-      descriptionKeyword: "Track slash",
-      hook: {
-        matcher: "*",
-        hooks: [{ type: "command", command: getTrackSlashCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Track slash command usage`
-      }
-    },
-    // ─── Auto-recall (search knowledge base on search tools + Bash errors) ────────
-    // Split into 4 precise matchers to avoid spawning a process for tools that
-    // would immediately exit (auto-recall only handles Bash/Grep/WebSearch/WebFetch).
+    // ─── PostToolUse (Bash/Grep/WebSearch/WebFetch): auto-recall ────
     ...["Bash", "Grep", "WebSearch", "WebFetch"].map((matcher) => ({
       eventType: "PostToolUse",
-      descriptionKeyword: `Auto-recall ${matcher}`,
+      descriptionKeyword: `Hook dispatch post-tool-use ${matcher}`,
       hook: {
         matcher,
-        hooks: [{ type: "command", command: getAutoRecallCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Auto-recall on ${matcher}`
+        hooks: [{ type: "command", command: getDispatchCommand("post-tool-use", tool, matcher) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch post-tool-use ${matcher}`
       }
     })),
-    // ─── Dashboard hooks (independent from tracking) ────────
-    {
-      eventType: "SessionStart",
-      descriptionKeyword: "Dashboard report",
-      hook: {
-        matcher: "*",
-        hooks: [{ type: "command", command: getDashboardReportCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Dashboard report on session start`
-      }
-    },
-    {
-      eventType: "Stop",
-      descriptionKeyword: "Dashboard stop",
-      hook: {
-        matcher: "*",
-        hooks: [{ type: "command", command: getDashboardReportCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Dashboard report on session stop`
-      }
-    },
-    {
-      eventType: "PostToolUse",
-      descriptionKeyword: "Dashboard tool",
-      hook: {
-        matcher: "*",
-        hooks: [{ type: "command", command: getDashboardReportCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Dashboard report on tool use`
-      }
-    },
+    // ─── UserPromptSubmit: track-slash + dashboard-report ────
     {
       eventType: "UserPromptSubmit",
-      descriptionKeyword: "Dashboard prompt",
+      descriptionKeyword: "Hook dispatch prompt-submit",
       hook: {
         matcher: "*",
-        hooks: [{ type: "command", command: getDashboardReportCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Dashboard report on prompt submit`
+        hooks: [{ type: "command", command: getDispatchCommand("prompt-submit", tool) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch prompt-submit`
       }
     }
   ];
@@ -927,26 +888,22 @@ function getClaudeHooks(tool) {
 function buildCursorHooks(tool) {
   return {
     sessionStart: [
-      { command: TEAMAI_PULL_COMMAND, timeout: 30 },
-      { command: getDashboardReportCommand(tool), timeout: 10 }
+      { command: getDispatchCommand("session-start", tool), timeout: 60 }
     ],
     stop: [
-      { command: TEAMAI_UPDATE_COMMAND, timeout: 10 },
-      { command: getDashboardReportCommand(tool), timeout: 10 },
-      { command: getContributeCheckCommand(tool), timeout: 10 }
+      { command: getDispatchCommand("stop", tool), timeout: 15 }
     ],
     postToolUse: [
-      { command: getTrackCommand(tool), timeout: 10, matcher: "Skill" },
-      { command: getDashboardReportCommand(tool), timeout: 10 },
+      { command: getDispatchCommand("post-tool-use", tool), timeout: 10 },
+      { command: getDispatchCommand("post-tool-use", tool, "Skill"), timeout: 10, matcher: "Skill" },
       ...["Bash", "Grep", "WebSearch", "WebFetch"].map((matcher) => ({
-        command: getAutoRecallCommand(tool),
-        timeout: 3,
+        command: getDispatchCommand("post-tool-use", tool, matcher),
+        timeout: 10,
         matcher
       }))
     ],
     beforeSubmitPrompt: [
-      { command: getTrackSlashCommand(tool), timeout: 10 },
-      { command: getDashboardReportCommand(tool), timeout: 10 }
+      { command: getDispatchCommand("prompt-submit", tool), timeout: 10 }
     ]
   };
 }
@@ -1063,6 +1020,22 @@ async function injectCursorHooks(hooksPath, tool) {
   }
   const desiredHooks = buildCursorHooks(tool);
   let changed = false;
+  for (const event of Object.keys(hooksJson.hooks)) {
+    const entries = hooksJson.hooks[event];
+    const filtered = entries.filter((h) => {
+      if (!isTeamaiHookCommand(h.command)) return true;
+      const subcmd = extractTeamaiSubcommand(h.command);
+      return subcmd === "hook-dispatch";
+    });
+    if (filtered.length !== entries.length) {
+      changed = true;
+      if (filtered.length === 0) {
+        delete hooksJson.hooks[event];
+      } else {
+        hooksJson.hooks[event] = filtered;
+      }
+    }
+  }
   const desiredEvents = new Set(Object.keys(desiredHooks));
   for (const event of Object.keys(hooksJson.hooks)) {
     if (desiredEvents.has(event)) continue;
@@ -1156,16 +1129,21 @@ async function injectHooksToAllTools(toolPaths, baseDir) {
     }
   }
 }
-var TEAMAI_PULL_COMMAND, TEAMAI_UPDATE_COMMAND, TEAMAI_HOOK_SUBCOMMANDS, CURSOR_TOOLS, TEAMAI_COMMAND_MARKERS;
+var TEAMAI_HOOK_SUBCOMMANDS, TEAMAI_LEGACY_HOOK_SUBCOMMANDS, CLAUDE_TO_CURSOR_EVENTS, CURSOR_TOOLS, TEAMAI_COMMAND_MARKERS;
 var init_hooks = __esm({
   "src/hooks.ts"() {
     "use strict";
     init_fs();
     init_logger();
     init_types();
-    TEAMAI_PULL_COMMAND = 'bash -lc "teamai pull 2>/dev/null" || true';
-    TEAMAI_UPDATE_COMMAND = 'bash -lc "teamai update 2>/dev/null" || true';
-    TEAMAI_HOOK_SUBCOMMANDS = ["pull", "update", "track", "track-slash", "dashboard-report", "contribute-check", "auto-recall"];
+    TEAMAI_HOOK_SUBCOMMANDS = ["hook-dispatch"];
+    TEAMAI_LEGACY_HOOK_SUBCOMMANDS = ["pull", "update", "track", "track-slash", "dashboard-report", "contribute-check", "auto-recall"];
+    CLAUDE_TO_CURSOR_EVENTS = {
+      SessionStart: "sessionStart",
+      Stop: "stop",
+      PostToolUse: "postToolUse",
+      UserPromptSubmit: "beforeSubmitPrompt"
+    };
     CURSOR_TOOLS = /* @__PURE__ */ new Set(["cursor"]);
     TEAMAI_COMMAND_MARKERS = [
       "teamai pull",
@@ -2396,6 +2374,10 @@ async function init(options) {
   if (options.scope === "project" || options.scope === "user") {
     scope = options.scope;
   } else {
+    const userPath = getTeamaiHome("user");
+    const projectPath = getTeamaiHome("project", process.cwd());
+    log.info(`  user    \u2192 ${userPath}/`);
+    log.info(`  project \u2192 ${projectPath}/`);
     const scopeAnswer = await askQuestion("Scope [user/project] (default: user): ", "user");
     if (scopeAnswer.toLowerCase() === "project") {
       scope = "project";
@@ -6414,7 +6396,27 @@ async function collectClaudemdFiles(repoPath, roleContext) {
   }
   return contents;
 }
+async function autoMigrateHooksIfNeeded() {
+  const home = process.env.HOME ?? "";
+  const primarySettings = path26.join(home, ".claude", "settings.json");
+  if (!await pathExists(primarySettings)) return;
+  const content = await readFileSafe(primarySettings);
+  if (!content) return;
+  if (content.includes("hook-dispatch")) return;
+  if (!content.includes("teamai")) return;
+  log.debug("Auto-migrating hooks to dispatch format...");
+  const { autoDetectInit: autoDetectInit2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { injectHooksToAllTools: injectHooksToAllTools2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+  const { localConfig, teamConfig } = await autoDetectInit2();
+  const baseDir = resolveBaseDir(localConfig);
+  await injectHooksToAllTools2(teamConfig.toolPaths, baseDir);
+  log.debug("Hooks migrated to dispatch format");
+}
 async function pull(options) {
+  try {
+    await autoMigrateHooksIfNeeded();
+  } catch {
+  }
   let userConfig = null;
   try {
     userConfig = await loadLocalConfigForScope("user");
@@ -11067,6 +11069,252 @@ var init_auto_recall = __esm({
   }
 });
 
+// src/hook-dispatch.ts
+function withTimeout(promise, ms, handlerName) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`Handler "${handlerName}" exceeded timeout of ${ms}ms`));
+    }, ms);
+    promise.then(
+      (val) => {
+        clearTimeout(timer);
+        resolve(val);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+function createDispatcher(config) {
+  return {
+    async dispatch(event, matcher, stdin, tool) {
+      const matched = config.handlers.filter((reg) => {
+        if (reg.event !== event) return false;
+        return reg.matcher === "*" || reg.matcher === matcher;
+      });
+      const settled = await Promise.allSettled(
+        matched.map((reg) => {
+          const timeoutMs = reg.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+          return withTimeout(reg.handler.execute(stdin, tool), timeoutMs, reg.handler.name);
+        })
+      );
+      let output = null;
+      const errors = [];
+      for (let i = 0; i < settled.length; i++) {
+        const result = settled[i];
+        const handlerName = matched[i].handler.name;
+        if (result.status === "rejected") {
+          errors.push({
+            handlerName,
+            error: result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+          });
+        } else if (result.status === "fulfilled" && result.value != null) {
+          if (output === null) {
+            output = result.value;
+          }
+        }
+      }
+      return { output, errors };
+    }
+  };
+}
+var DEFAULT_TIMEOUT_MS;
+var init_hook_dispatch = __esm({
+  "src/hook-dispatch.ts"() {
+    "use strict";
+    DEFAULT_TIMEOUT_MS = 6e4;
+  }
+});
+
+// src/hook-handlers.ts
+function buildHandlerRegistry() {
+  return [
+    // ─── SessionStart ─────────────────────────────────
+    { event: "session-start", matcher: "*", handler: pullHandler, timeoutMs: PULL_TIMEOUT_MS },
+    { event: "session-start", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS },
+    // ─── Stop ─────────────────────────────────────────
+    { event: "stop", matcher: "*", handler: updateHandler, timeoutMs: UPDATE_TIMEOUT_MS },
+    { event: "stop", matcher: "*", handler: contributeCheckHandler, timeoutMs: CONTRIBUTE_CHECK_TIMEOUT_MS },
+    { event: "stop", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS },
+    // ─── PostToolUse ──────────────────────────────────
+    { event: "post-tool-use", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS },
+    { event: "post-tool-use", matcher: "Skill", handler: trackHandler, timeoutMs: TRACK_TIMEOUT_MS },
+    ...["Bash", "Grep", "WebSearch", "WebFetch"].map((m) => ({
+      event: "post-tool-use",
+      matcher: m,
+      handler: autoRecallHandler,
+      timeoutMs: AUTO_RECALL_TIMEOUT_MS
+    })),
+    // ─── UserPromptSubmit ─────────────────────────────
+    { event: "prompt-submit", matcher: "*", handler: trackSlashHandler, timeoutMs: TRACK_TIMEOUT_MS },
+    { event: "prompt-submit", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS }
+  ];
+}
+var PULL_TIMEOUT_MS, UPDATE_TIMEOUT_MS, TRACK_TIMEOUT_MS, DASHBOARD_TIMEOUT_MS, CONTRIBUTE_CHECK_TIMEOUT_MS, AUTO_RECALL_TIMEOUT_MS, pullHandler, updateHandler, dashboardReportHandler, trackHandler, trackSlashHandler, contributeCheckHandler, autoRecallHandler;
+var init_hook_handlers = __esm({
+  "src/hook-handlers.ts"() {
+    "use strict";
+    PULL_TIMEOUT_MS = 6e4;
+    UPDATE_TIMEOUT_MS = 1e4;
+    TRACK_TIMEOUT_MS = 5e3;
+    DASHBOARD_TIMEOUT_MS = 5e3;
+    CONTRIBUTE_CHECK_TIMEOUT_MS = 1e4;
+    AUTO_RECALL_TIMEOUT_MS = 1e4;
+    pullHandler = {
+      name: "pull",
+      async execute(_stdin, _tool) {
+        const { pull: pull2 } = await Promise.resolve().then(() => (init_pull(), pull_exports));
+        await pull2({ silent: true });
+        return null;
+      }
+    };
+    updateHandler = {
+      name: "update",
+      async execute(_stdin, _tool) {
+        const { doUpdate: doUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
+        await doUpdate2();
+        return null;
+      }
+    };
+    dashboardReportHandler = {
+      name: "dashboard-report",
+      async execute(stdin, tool) {
+        const { parseHookEvent: parseHookEvent2, appendEvent: appendEvent2, compactEvents: compactEvents2 } = await Promise.resolve().then(() => (init_dashboard_collector(), dashboard_collector_exports));
+        const raw = JSON.stringify(stdin);
+        const event = await parseHookEvent2(raw, tool);
+        if (event) {
+          await appendEvent2(event);
+          compactEvents2().catch(() => {
+          });
+        }
+        return null;
+      }
+    };
+    trackHandler = {
+      name: "track",
+      async execute(stdin, tool) {
+        const { extractSkillName: extractSkillName2, isValidSkillName: isValidSkillName2, appendUsageEvent: appendUsageEvent2, updateKnownSkills: updateKnownSkills2 } = await Promise.resolve().then(() => (init_usage_tracker(), usage_tracker_exports));
+        const toolName = stdin.tool_name;
+        if (typeof toolName !== "string") return null;
+        const toolInput = stdin.tool_input;
+        if (!toolInput || typeof toolInput !== "object") return null;
+        let skillName = null;
+        let toolSource = tool;
+        if (toolName === "Skill") {
+          skillName = extractSkillName2(toolInput);
+        } else if (toolName === "Read") {
+          const filePath = (typeof toolInput.file_path === "string" ? toolInput.file_path : null) ?? (typeof toolInput.path === "string" ? toolInput.path : null);
+          if (typeof filePath === "string" && /\/SKILL\.md$/i.test(filePath)) {
+            skillName = extractSkillName2({ skill: filePath });
+            toolSource = "cursor";
+          }
+        } else {
+          return null;
+        }
+        if (!skillName || !isValidSkillName2(skillName)) return null;
+        await appendUsageEvent2({ skill: skillName, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool: toolSource });
+        await updateKnownSkills2(skillName);
+        return null;
+      }
+    };
+    trackSlashHandler = {
+      name: "track-slash",
+      async execute(stdin, tool) {
+        const { extractSkillName: extractSkillName2, isValidSkillName: isValidSkillName2, appendUsageEvent: appendUsageEvent2, updateKnownSkills: updateKnownSkills2 } = await Promise.resolve().then(() => (init_usage_tracker(), usage_tracker_exports));
+        const prompt = stdin.prompt;
+        if (typeof prompt !== "string" || !prompt.startsWith("/")) return null;
+        const match = prompt.match(/^\/([\w-]+)/);
+        if (!match) return null;
+        const skillName = match[1];
+        if (!isValidSkillName2(skillName)) return null;
+        await appendUsageEvent2({ skill: skillName, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool });
+        await updateKnownSkills2(skillName);
+        return null;
+      }
+    };
+    contributeCheckHandler = {
+      name: "contribute-check",
+      async execute(stdin, _tool) {
+        const { contributeCheckForSession: contributeCheckForSession2 } = await Promise.resolve().then(() => (init_contribute_check(), contribute_check_exports));
+        const sessionId = typeof stdin.session_id === "string" ? stdin.session_id : null;
+        if (!sessionId) return null;
+        const { hint } = await contributeCheckForSession2(sessionId);
+        if (hint) {
+          return JSON.stringify({ stopReason: hint });
+        }
+        return null;
+      }
+    };
+    autoRecallHandler = {
+      name: "auto-recall",
+      async execute(stdin, _tool) {
+        const { autoRecall: autoRecall2 } = await Promise.resolve().then(() => (init_auto_recall(), auto_recall_exports));
+        let capturedOutput = null;
+        const originalWrite = process.stdout.write.bind(process.stdout);
+        process.stdout.write = ((chunk) => {
+          if (typeof chunk === "string") {
+            capturedOutput = chunk;
+          } else if (Buffer.isBuffer(chunk)) {
+            capturedOutput = chunk.toString();
+          }
+          return true;
+        });
+        try {
+          await autoRecall2();
+        } finally {
+          process.stdout.write = originalWrite;
+        }
+        return capturedOutput;
+      }
+    };
+  }
+});
+
+// src/hook-dispatch-cli.ts
+var hook_dispatch_cli_exports = {};
+__export(hook_dispatch_cli_exports, {
+  hookDispatchCli: () => hookDispatchCli
+});
+async function readStdin4() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function hookDispatchCli(event, tool, matcher) {
+  const raw = await readStdin4();
+  let stdin = {};
+  if (raw.trim()) {
+    try {
+      stdin = JSON.parse(raw);
+    } catch {
+      log.debug(`hook-dispatch: failed to parse STDIN JSON for event=${event}`);
+      return;
+    }
+  }
+  const registry = buildHandlerRegistry();
+  const dispatcher = createDispatcher({ handlers: registry });
+  const result = await dispatcher.dispatch(event, matcher, stdin, tool);
+  for (const err of result.errors) {
+    log.debug(`hook-dispatch: handler "${err.handlerName}" failed: ${err.error.message}`);
+  }
+  if (result.output) {
+    process.stdout.write(result.output);
+  }
+}
+var init_hook_dispatch_cli = __esm({
+  "src/hook-dispatch-cli.ts"() {
+    "use strict";
+    init_hook_dispatch();
+    init_hook_handlers();
+    init_logger();
+  }
+});
+
 // src/index.ts
 init_logger();
 import { createRequire as createRequire2 } from "module";
@@ -11343,5 +11591,9 @@ program.command("auto-recall").description("Auto-recall team knowledge on tool e
     await autoRecall2();
   }
 });
+program.command("hook-dispatch <event>").description("Unified hook dispatcher \u2014 handles all teamai hooks for a given event in one process").option("--tool <name>", "Tool identifier (e.g. claude, claude-internal, cursor)").option("--matcher <matcher>", "Hook matcher for PostToolUse (e.g. Skill, Bash)").action(async (event, cmdOpts) => {
+  const { hookDispatchCli: hookDispatchCli2 } = await Promise.resolve().then(() => (init_hook_dispatch_cli(), hook_dispatch_cli_exports));
+  await hookDispatchCli2(event, cmdOpts.tool ?? "claude", cmdOpts.matcher ?? "*");
+});
 program.parse();
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "teamai-cli",
-  "version": "0.16.5",
+  "version": "0.16.7",
   "description": "TeamAI — the team harness for AI agents (skill sync + shared knowledge base, powered by Git)",
   "type": "module",
   "bin": {
-    "teamai": "./dist/index.js"
+    "teamai": "dist/index.js"
   },
   "files": [
     "dist/**/*.js",
@@ -29,7 +29,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Tencent/teamai-cli.git"
+    "url": "git+https://github.com/Tencent/teamai-cli.git"
   },
   "homepage": "https://github.com/Tencent/teamai-cli#readme",
   "bugs": {

package/skills/teamai-wiki/SKILL.md

@@ -243,10 +243,10 @@ When invoked, first determine the subcommand (init/ingest/query/lint/status/expo
 
 #### Step 1 — Parse arguments
 
-- `WIKI_DIR`: wiki 目录路径。按以下顺序检测：
-  1. team repo 中的 `wiki/` 目录（如果当前项目已通过 `teamai init` 配置）→ 首选
-  2. `~/.claude-internal/wiki/` 或 `~/.claude/wiki/`（本地 AI 工具 wiki 目录）
-  3. 当前目录的 `./wiki/`（fallback）
+- `WIKI_DIR`: 根据当前项目的 teamai scope 决定：
+  - 读取 `<projectRoot>/.teamai/config.yaml` 中的 `scope` 字段
+  - **project scope** → `<projectRoot>/.teamai/wiki/`
+  - **user scope**（或无项目配置时）→ `~/.teamai/wiki/`
 - `SOURCE_DIR`: 可选的 `dir` 参数
 
 如果 `WIKI_DIR` 已经存在且包含 `_metadata.json`，提示用户已经初始化过，询问是否要重新初始化。
@@ -1009,7 +1009,7 @@ Wiki exported to: <path>
 8. **_metadata.json 是真相来源** — 页面列表、文件哈希、链接图都以此为准。
 9. **命名一致性** — 文件名 kebab-case，标题 Title Case 或人类可读中文。
 10. **幂等性** — 重复 ingest 同一源目录应产生相同结果（不会重复创建页面）。
-11. **wiki 路径推断** — 优先使用 team repo 的 wiki/ 目录（通过 `teamai pull` 同步到本地）；其次检查 `~/.claude-internal/wiki/` 或 `~/.claude/wiki/`；最后 fallback 到 `./wiki/`。
+11. **wiki 路径** — 读取 `<projectRoot>/.teamai/config.yaml` 的 `scope` 字段：project scope 用 `<projectRoot>/.teamai/wiki/`，user scope 用 `~/.teamai/wiki/`。与 teamai push/pull 的 `WikiHandler.getSharedWikiDir()` 逻辑对齐。
 12. **Obsidian 兼容** — 所有 `[[links]]` 使用 Obsidian 格式，方便用户在 Obsidian 中直接浏览。
 13. **语言** — Wiki 页面内容默认使用中文撰写，技术术语保持英文原文。
 14. **智能分类** — LLM 根据内容自动判断页面归属哪个分类目录，无需用户指定。