skillrepo 1.9.0 → 1.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillrepo",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "Set up SkillRepo in any IDE — one command",
   "type": "module",
   "bin": {

package/src/hooks/skillrepo-prompt-match.mjs

@@ -222,6 +222,83 @@ export function sendTelemetry(config, payload) {
   }).catch(() => { /* telemetry errors are non-critical */ });
 }
 
+// ---------------------------------------------------------------------------
+// Activation telemetry for rules-delivered matched skills
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the shared activation dedup state (same file as pretool-activation hook).
+ * This prevents double-counting: if rules_match fires first, pretool_hook
+ * won't re-report the same skill in the same session, and vice versa.
+ */
+export function readActivationState(sessionId) {
+  const hash = createHash("sha256").update(sessionId || "default").digest("hex").slice(0, 16);
+  const statePath = join(tmpdir(), `skillrepo-activation-${hash}.json`);
+
+  try {
+    return { path: statePath, state: JSON.parse(readFileSync(statePath, "utf-8")) };
+  } catch {
+    return { path: statePath, state: { reported: {} } };
+  }
+}
+
+/**
+ * Filter matches to exclude skills already reported as activated in this session.
+ */
+export function deduplicateActivations(matches, sessionState) {
+  return matches.filter(m => {
+    const key = `${m.skill.owner}/${m.skill.name}`;
+    return !sessionState.reported[key];
+  });
+}
+
+/**
+ * Mark skills as reported in activation state.
+ */
+export function updateActivationState(statePath, state, reportedMatches) {
+  for (const m of reportedMatches) {
+    const key = `${m.skill.owner}/${m.skill.name}`;
+    state.reported[key] = new Date().toISOString();
+  }
+  try { writeFileSync(statePath, JSON.stringify(state), "utf-8"); }
+  catch { /* non-critical */ }
+}
+
+/**
+ * Build activation telemetry payload for rules-delivered matched skills.
+ */
+export function buildActivationPayload(matches, sessionInfo) {
+  const events = matches.slice(0, MAX_EVENTS_PER_BATCH).map(m => ({
+    skillOwner: m.skill.owner,
+    skillName: m.skill.name,
+    skillVersion: m.skill.version ?? "",
+    activatedAt: new Date().toISOString(),
+    ide: sessionInfo.ide || "claude-code",
+    sessionHash: sessionInfo.sessionHash,
+    userId: sessionInfo.userId || undefined,
+    source: "rules_match",
+    toolPattern: undefined,
+  }));
+
+  return { events };
+}
+
+/**
+ * Fire-and-forget POST to activation telemetry endpoint.
+ */
+export function sendActivationTelemetry(config, payload) {
+  const url = `${config.serverUrl}/api/v1/telemetry/activation`;
+
+  fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(payload),
+  }).catch(() => { /* telemetry errors are non-critical */ });
+}
+
 // ---------------------------------------------------------------------------
 // Main entry point
 // ---------------------------------------------------------------------------
@@ -281,6 +358,27 @@ export async function main(input) {
 
   sendTelemetry(config, payload); // fire-and-forget — do NOT await
 
+  // ── Send activation telemetry for rules-delivered matches ───
+  // For skills delivered via .claude/rules/, the match IS the activation
+  // signal — the skill was in context and the prompt was relevant.
+  // Uses the shared activation dedup state so pretool_hook won't
+  // double-report the same skill in this session.
+  const rulesMatches = newMatches.filter(m => m.skill.isRulesDelivered);
+  if (rulesMatches.length > 0) {
+    const { path: actStatePath, state: actState } = readActivationState(sessionId);
+    const newActivations = deduplicateActivations(rulesMatches, actState);
+
+    if (newActivations.length > 0) {
+      const actPayload = buildActivationPayload(newActivations, {
+        ide: "claude-code",
+        sessionHash,
+        userId: config.userId,
+      });
+      sendActivationTelemetry(config, actPayload); // fire-and-forget
+      updateActivationState(actStatePath, actState, newActivations);
+    }
+  }
+
   // ── Update session state ────────────────────────────────────
   updateSessionState(statePath, state, newMatches);
 

package/src/test/hooks/skillrepo-prompt-match.test.mjs

@@ -7,11 +7,11 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import {
-  mkdtempSync, rmSync, readFileSync,
+  mkdtempSync, rmSync, readFileSync, writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-
+import { createHash } from "node:crypto";
 import {
   matchSkills,
   readSessionState,
@@ -19,6 +19,11 @@ import {
   updateSessionState,
   buildTelemetryPayload,
   sendTelemetry,
+  readActivationState,
+  deduplicateActivations,
+  updateActivationState,
+  buildActivationPayload,
+  sendActivationTelemetry,
   main,
 } from "../../hooks/skillrepo-prompt-match.mjs";
 
@@ -336,6 +341,145 @@ describe("sendTelemetry", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// buildActivationPayload — rules-match activation telemetry
+// ---------------------------------------------------------------------------
+
+describe("buildActivationPayload", () => {
+  it("produces correct payload shape with source rules_match", () => {
+    const matches = [
+      { skill: makeSkill({ owner: "alice", name: "deploy-flow", version: "2.0.0", isRulesDelivered: true }), score: 5 },
+    ];
+    const sessionInfo = { ide: "claude-code", sessionHash: "abc123", userId: "user-42" };
+
+    const payload = buildActivationPayload(matches, sessionInfo);
+
+    assert.equal(payload.events.length, 1);
+    const event = payload.events[0];
+    assert.equal(event.skillOwner, "alice");
+    assert.equal(event.skillName, "deploy-flow");
+    assert.equal(event.skillVersion, "2.0.0");
+    assert.equal(event.ide, "claude-code");
+    assert.equal(event.sessionHash, "abc123");
+    assert.equal(event.userId, "user-42");
+    assert.equal(event.source, "rules_match");
+    assert.equal(event.toolPattern, undefined);
+    assert.ok(event.activatedAt); // ISO 8601 string
+  });
+
+  it("caps events at 50 per batch", () => {
+    const matches = Array.from({ length: 60 }, (_, i) => ({
+      skill: makeSkill({ owner: "o", name: `s-${i}` }),
+      score: 1,
+    }));
+    const payload = buildActivationPayload(matches, { ide: "claude-code", sessionHash: "x" });
+    assert.equal(payload.events.length, 50);
+  });
+
+  it("handles missing optional fields gracefully", () => {
+    const matches = [
+      { skill: makeSkill({ version: null, isRulesDelivered: undefined }), score: 1 },
+    ];
+    const payload = buildActivationPayload(matches, {
+      ide: "claude-code",
+      sessionHash: "hash",
+      userId: null,
+    });
+
+    const event = payload.events[0];
+    assert.equal(event.skillVersion, "");
+    assert.equal(event.userId, undefined); // null → undefined via || operator
+    assert.equal(event.source, "rules_match");
+    assert.equal(event.toolPattern, undefined);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// sendActivationTelemetry — error resilience
+// ---------------------------------------------------------------------------
+
+describe("sendActivationTelemetry", () => {
+  it("does not throw on network failure", async () => {
+    const config = { apiKey: "sk_live_test", serverUrl: "http://127.0.0.1:1" };
+    const payload = { events: [{ skillOwner: "o", skillName: "s", activatedAt: new Date().toISOString(), ide: "test", sessionHash: "x", source: "rules_match" }] };
+
+    // Should resolve without throwing
+    await sendActivationTelemetry(config, payload);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// readActivationState / deduplicateActivations / updateActivationState
+// — shared dedup state between rules_match and pretool_hook
+// ---------------------------------------------------------------------------
+
+describe("activation dedup state", () => {
+  it("returns empty state when file does not exist", () => {
+    const { state } = readActivationState("nonexistent-session-id-" + Date.now());
+    assert.deepEqual(state, { reported: {} });
+  });
+
+  it("reads activation state from shared tmpdir file", () => {
+    const sessionId = "dedup-read-test-" + Date.now();
+    const hash = createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+    const statePath = join(tmpdir(), `skillrepo-activation-${hash}.json`);
+
+    // Pre-populate state file
+    writeFileSync(statePath, JSON.stringify({ reported: { "alice/deploy": "2025-01-01T00:00:00Z" } }));
+
+    try {
+      const { state } = readActivationState(sessionId);
+      assert.equal(state.reported["alice/deploy"], "2025-01-01T00:00:00Z");
+    } finally {
+      rmSync(statePath, { force: true });
+    }
+  });
+
+  it("filters out already-reported skills", () => {
+    const matches = [
+      { skill: makeSkill({ owner: "alice", name: "deploy" }), score: 5 },
+      { skill: makeSkill({ owner: "bob", name: "review" }), score: 3 },
+    ];
+    const sessionState = { reported: { "alice/deploy": "2025-01-01T00:00:00Z" } };
+
+    const filtered = deduplicateActivations(matches, sessionState);
+
+    assert.equal(filtered.length, 1);
+    assert.equal(filtered[0].skill.owner, "bob");
+    assert.equal(filtered[0].skill.name, "review");
+  });
+
+  it("persists reported skills to state file", () => {
+    const sessionId = "dedup-write-test-" + Date.now();
+    const hash = createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+    const statePath = join(tmpdir(), `skillrepo-activation-${hash}.json`);
+    const state = { reported: {} };
+
+    const matches = [
+      { skill: makeSkill({ owner: "alice", name: "deploy" }), score: 5 },
+    ];
+
+    try {
+      updateActivationState(statePath, state, matches);
+
+      const persisted = JSON.parse(readFileSync(statePath, "utf-8"));
+      assert.ok(persisted.reported["alice/deploy"]);
+    } finally {
+      rmSync(statePath, { force: true });
+    }
+  });
+
+  it("uses same state file path format as pretool-activation hook", () => {
+    const sessionId = "cross-hook-dedup-test";
+    const hash = createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+    const expectedPath = join(tmpdir(), `skillrepo-activation-${hash}.json`);
+
+    const { path } = readActivationState(sessionId);
+
+    assert.equal(path, expectedPath);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // main() integration via subprocess — avoids test runner interference
 // ---------------------------------------------------------------------------