skillo 0.1.5 → 0.2.2

package/dist/config-P5EM5L7N.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  getConfigValue,
+  getDefaultConfig,
+  loadConfig,
+  saveConfig,
+  setConfigValue
+} from "./chunk-CPL3P2OF.js";
+import "./chunk-WJKZWKER.js";
+export {
+  getConfigValue,
+  getDefaultConfig,
+  loadConfig,
+  saveConfig,
+  setConfigValue
+};
+//# sourceMappingURL=config-P5EM5L7N.js.map

package/dist/config-P5EM5L7N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/daemon-runner.js

@@ -1,5 +1,5 @@
 // src/daemon-runner.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync2, unlinkSync, readFileSync as readFileSync2, readdirSync, appendFileSync } from "fs";
+import { existsSync as existsSync6, writeFileSync as writeFileSync4, unlinkSync, readFileSync as readFileSync4, readdirSync as readdirSync2, appendFileSync } from "fs";
 
 // src/core/config.ts
 import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
@@ -25,11 +25,19 @@ function getConfigDir() {
   if (xdgConfig) return join(xdgConfig, "skillo");
   return join(getHomeDir(), ".config", "skillo");
 }
-function ensureDirectory(path2) {
-  if (existsSync(path2)) {
+function getSkillsDir() {
+  const envPath = process.env.SKILLO_SKILLS_DIR;
+  if (envPath) return envPath;
+  return join(getClaudeDir(), "skills");
+}
+function getClaudeDir() {
+  return join(getHomeDir(), ".claude");
+}
+function ensureDirectory(path3) {
+  if (existsSync(path3)) {
     return false;
   }
-  mkdirSync(path2, { recursive: true });
+  mkdirSync(path3, { recursive: true });
   return true;
 }
 function getLogFile() {
@@ -130,8 +138,8 @@ function deepMerge(base, override) {
   }
   return result;
 }
-function loadConfig(path2) {
-  const configPath = path2 || getConfigFile();
+function loadConfig(path3) {
+  const configPath = path3 || getConfigFile();
   if (!existsSync2(configPath)) {
     return getDefaultConfig();
   }
@@ -145,8 +153,8 @@ function loadConfig(path2) {
     return getDefaultConfig();
   }
 }
-function saveConfig(config, path2) {
-  const configPath = path2 || getConfigFile();
+function saveConfig(config, path3) {
+  const configPath = path3 || getConfigFile();
   ensureDirectory(dirname(configPath));
   const converted = convertKeysToSnakeCase(config);
   const content = YAML.stringify(converted, {
@@ -500,16 +508,16 @@ var ApiClient = class {
   /**
    * Disconnect a project from tracking
    */
-  async disconnectProject(path2) {
-    return this.request(`/projects/connect?path=${encodeURIComponent(path2)}`, {
+  async disconnectProject(path3) {
+    return this.request(`/projects/connect?path=${encodeURIComponent(path3)}`, {
       method: "DELETE"
     });
   }
   /**
    * Get tracking status for a project
    */
-  async getProjectStatus(path2) {
-    return this.request(`/projects/connect?path=${encodeURIComponent(path2)}`, {
+  async getProjectStatus(path3) {
+    return this.request(`/projects/connect?path=${encodeURIComponent(path3)}`, {
       method: "GET"
     });
   }
@@ -525,8 +533,8 @@ var ApiClient = class {
    * Check if a path is in a tracked project
    * Returns the project if tracked, null if not
    */
-  async isProjectTracked(path2) {
-    const result = await this.getProjectStatus(path2);
+  async isProjectTracked(path3) {
+    const result = await this.getProjectStatus(path3);
     if (result.success && result.data?.connected) {
       return {
         tracked: true,
@@ -717,6 +725,287 @@ var ClaudeWatcher = class {
   }
 };
 
+// src/core/skill-usage-detector.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as readline2 from "readline";
+var MAX_NEW_BYTES_PER_FILE = 2 * 1024 * 1024;
+var OFFSETS_FILE = "skill-usage-offsets.json";
+var SkillUsageDetector = class {
+  intervalId = null;
+  intervalMs;
+  callbacks;
+  client;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.intervalMs = options.intervalMs || 3e4;
+    this.callbacks = options.callbacks || {};
+  }
+  log(level, msg) {
+    this.callbacks.log?.(level, msg);
+  }
+  async start() {
+    this.initOffsets();
+    this.log("INFO", "Skill usage detector started");
+    this.intervalId = setInterval(() => this.detect(), this.intervalMs);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+  /** Build slug inventory from ~/.claude/skills/ */
+  getDeployedSkillSlugs() {
+    const slugs = /* @__PURE__ */ new Set();
+    const skillsDir = getSkillsDir();
+    if (!fs2.existsSync(skillsDir)) return slugs;
+    try {
+      const entries = fs2.readdirSync(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+        const skillFile = path2.join(skillsDir, entry.name, "SKILL.md");
+        if (fs2.existsSync(skillFile)) {
+          slugs.add(entry.name);
+        }
+      }
+    } catch {
+    }
+    return slugs;
+  }
+  /** Encode project path to Claude's directory name format */
+  encodeProjectPath(projectPath) {
+    return projectPath.replace(/\//g, "-");
+  }
+  /** Find session JSONL files for tracked projects */
+  getSessionFiles() {
+    const claudeDir = getClaudeDir();
+    const projectsDir = path2.join(claudeDir, "projects");
+    if (!fs2.existsSync(projectsDir)) return [];
+    const files = [];
+    try {
+      const projectDirs = fs2.readdirSync(projectsDir, { withFileTypes: true });
+      for (const dir of projectDirs) {
+        if (!dir.isDirectory()) continue;
+        const dirPath = path2.join(projectsDir, dir.name);
+        const jsonlFiles = fs2.readdirSync(dirPath).filter(
+          (f) => f.endsWith(".jsonl") && !f.startsWith("agent-")
+        );
+        for (const f of jsonlFiles) {
+          files.push(path2.join(dirPath, f));
+        }
+      }
+    } catch {
+    }
+    return files;
+  }
+  /** Load persisted offsets */
+  loadOffsets() {
+    const offsetsPath = path2.join(getDataDir(), OFFSETS_FILE);
+    try {
+      if (fs2.existsSync(offsetsPath)) {
+        return JSON.parse(fs2.readFileSync(offsetsPath, "utf-8"));
+      }
+    } catch {
+    }
+    return {};
+  }
+  /** Save offsets */
+  saveOffsets(state) {
+    ensureDirectory(getDataDir());
+    const offsetsPath = path2.join(getDataDir(), OFFSETS_FILE);
+    try {
+      fs2.writeFileSync(offsetsPath, JSON.stringify(state), "utf-8");
+    } catch {
+    }
+  }
+  /** Initialize offsets to current file sizes (skip existing data) */
+  initOffsets() {
+    const files = this.getSessionFiles();
+    const state = this.loadOffsets();
+    for (const file of files) {
+      if (!state[file]) {
+        try {
+          const stats = fs2.statSync(file);
+          state[file] = { byteOffset: stats.size, lastModified: stats.mtimeMs };
+        } catch {
+        }
+      }
+    }
+    this.saveOffsets(state);
+  }
+  /** Main detection cycle */
+  async detect() {
+    try {
+      const skillSlugs = this.getDeployedSkillSlugs();
+      if (skillSlugs.size === 0) return;
+      const skillsDir = getSkillsDir();
+      const files = this.getSessionFiles();
+      const offsets = this.loadOffsets();
+      const events = [];
+      for (const file of files) {
+        try {
+          const stats = fs2.statSync(file);
+          const currentOffset = offsets[file]?.byteOffset ?? 0;
+          const currentMtime = offsets[file]?.lastModified ?? 0;
+          if (stats.size <= currentOffset && stats.mtimeMs === currentMtime) continue;
+          const startOffset = Math.max(currentOffset, stats.size - MAX_NEW_BYTES_PER_FILE);
+          if (stats.size <= startOffset) {
+            offsets[file] = { byteOffset: stats.size, lastModified: stats.mtimeMs };
+            continue;
+          }
+          const stream = fs2.createReadStream(file, {
+            start: startOffset,
+            encoding: "utf-8"
+          });
+          const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+          for await (const line of rl) {
+            if (!line.trim()) continue;
+            try {
+              const entry = JSON.parse(line);
+              const msg = entry?.message;
+              if (!msg || msg.role !== "assistant") continue;
+              const content = msg.content;
+              if (!Array.isArray(content)) continue;
+              const sessionId = entry.sessionId || "";
+              const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+              const cwd = entry.cwd || "";
+              for (const block of content) {
+                if (block?.type !== "tool_use") continue;
+                const toolName = block.name;
+                const toolInput = block.input || {};
+                if (toolName === "Read") {
+                  const filePath = toolInput.file_path || "";
+                  if (filePath.includes("/skills/") && filePath.endsWith("/SKILL.md")) {
+                    const parts = filePath.split("/skills/");
+                    if (parts.length >= 2) {
+                      const afterSkills = parts[parts.length - 1];
+                      const slug = afterSkills.split("/")[0];
+                      if (slug && skillSlugs.has(slug)) {
+                        events.push({
+                          skillSlug: slug,
+                          claudeSessionId: sessionId,
+                          projectPath: cwd,
+                          timestamp
+                        });
+                      }
+                    }
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+          offsets[file] = { byteOffset: stats.size, lastModified: stats.mtimeMs };
+        } catch {
+        }
+      }
+      for (const key of Object.keys(offsets)) {
+        if (!fs2.existsSync(key)) {
+          delete offsets[key];
+        }
+      }
+      this.saveOffsets(offsets);
+      const seen = /* @__PURE__ */ new Set();
+      const uniqueEvents = events.filter((e) => {
+        const key = `${e.skillSlug}:${e.claudeSessionId}:${e.timestamp}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
+      if (uniqueEvents.length > 0) {
+        this.log("INFO", `Detected ${uniqueEvents.length} skill usage(s), reporting...`);
+        const response = await this.client.reportSkillUsage(uniqueEvents);
+        if (response.success) {
+          this.log("INFO", `Reported ${response.data?.logged ?? 0} skill usage(s)`);
+          this.callbacks.onDetection?.(response.data?.logged ?? 0);
+        } else {
+          this.log("ERROR", `Report failed: ${response.error}`);
+        }
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log("ERROR", `Detection error: ${err.message}`);
+      this.callbacks.onError?.(err);
+    }
+  }
+};
+
+// src/utils/status-writer.ts
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+var STATUS_FILE = "daemon-status.json";
+var WRITE_INTERVAL_MS = 1e4;
+var StatusWriter = class _StatusWriter {
+  intervalId = null;
+  status;
+  filePath;
+  constructor() {
+    this.filePath = join4(getDataDir(), STATUS_FILE);
+    this.status = {
+      running: true,
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      claudeWatcher: { lastSync: null, promptsSynced: 0, lastError: null },
+      skillDetector: { deployedSkills: 0, usagesDetected: 0, lastDetection: null, lastError: null },
+      trackedProjects: [],
+      activeSessions: 0
+    };
+  }
+  /** Start periodic writes */
+  start() {
+    ensureDirectory(getDataDir());
+    this.write();
+    this.intervalId = setInterval(() => this.write(), WRITE_INTERVAL_MS);
+  }
+  /** Stop writing and mark as not running */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.status.running = false;
+    this.status.pid = null;
+    this.status.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.write();
+  }
+  /** Merge partial status updates */
+  update(partial) {
+    if (partial.claudeWatcher) {
+      this.status.claudeWatcher = { ...this.status.claudeWatcher, ...partial.claudeWatcher };
+      delete partial.claudeWatcher;
+    }
+    if (partial.skillDetector) {
+      this.status.skillDetector = { ...this.status.skillDetector, ...partial.skillDetector };
+      delete partial.skillDetector;
+    }
+    Object.assign(this.status, partial);
+  }
+  /** Get the status file path */
+  static getStatusFilePath() {
+    return join4(getDataDir(), STATUS_FILE);
+  }
+  /** Read current status from disk (static, for tray/status commands) */
+  static read() {
+    const filePath = _StatusWriter.getStatusFilePath();
+    try {
+      if (existsSync5(filePath)) {
+        return JSON.parse(readFileSync3(filePath, "utf-8"));
+      }
+    } catch {
+    }
+    return null;
+  }
+  write() {
+    this.status.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      writeFileSync3(this.filePath, JSON.stringify(this.status, null, 2), "utf-8");
+    } catch {
+    }
+  }
+};
+
 // src/daemon-runner.ts
 function log(level, msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${msg}
@@ -734,7 +1023,7 @@ async function updateTrackedProjectsCache(client) {
         updatedAt: Date.now(),
         projects: result.data.projects.filter((p) => p.trackingEnabled).map((p) => ({ path: p.path, name: p.name }))
       };
-      writeFileSync2(getTrackedProjectsCacheFile(), JSON.stringify(cacheData, null, 2));
+      writeFileSync4(getTrackedProjectsCacheFile(), JSON.stringify(cacheData, null, 2));
       log("DEBUG", `Updated tracked projects cache: ${cacheData.projects.length} project(s)`);
     }
   } catch (error) {
@@ -743,9 +1032,9 @@ async function updateTrackedProjectsCache(client) {
 }
 async function cleanupStaleSessions(client) {
   const sessionsDir = getActiveSessionsDir();
-  if (!existsSync4(sessionsDir)) return;
+  if (!existsSync6(sessionsDir)) return;
   try {
-    const files = readdirSync(sessionsDir);
+    const files = readdirSync2(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
       const pid = parseInt(file.replace(".json", ""), 10);
@@ -758,7 +1047,7 @@ async function cleanupStaleSessions(client) {
       }
       if (!isRunning) {
         try {
-          const sessionData = JSON.parse(readFileSync2(`${sessionsDir}/${file}`, "utf-8"));
+          const sessionData = JSON.parse(readFileSync4(`${sessionsDir}/${file}`, "utf-8"));
           if (sessionData.sessionId) {
             await client.endSession(sessionData.sessionId);
             log("INFO", `Ended stale session ${sessionData.sessionId.slice(0, 8)} (PID ${pid} dead)`);
@@ -778,11 +1067,13 @@ async function cleanupStaleSessions(client) {
 }
 async function main() {
   const pidFile = getPidFile();
-  writeFileSync2(pidFile, String(process.pid));
+  writeFileSync4(pidFile, String(process.pid));
   log("INFO", `Daemon starting (PID: ${process.pid})`);
+  const statusWriter = new StatusWriter();
   const cleanup = () => {
     log("INFO", "Daemon shutting down");
-    if (existsSync4(pidFile)) {
+    statusWriter.stop();
+    if (existsSync6(pidFile)) {
       try {
         unlinkSync(pidFile);
       } catch {
@@ -818,9 +1109,34 @@ async function main() {
     }
   });
   await watcher.start();
-  setInterval(() => updateTrackedProjectsCache(client), 6e4);
+  const skillDetector = new SkillUsageDetector(client, {
+    intervalMs: 3e4,
+    callbacks: {
+      onDetection: (count) => {
+        log("INFO", `Detected ${count} skill usage(s)`);
+        statusWriter.update({ skillDetector: { usagesDetected: count, lastDetection: (/* @__PURE__ */ new Date()).toISOString(), lastError: null } });
+      },
+      onError: (err) => {
+        log("ERROR", `Skill detection error: ${err.message}`);
+        statusWriter.update({ skillDetector: { lastError: err.message } });
+      },
+      log: (level, msg) => log(level, msg)
+    }
+  });
+  await skillDetector.start();
+  statusWriter.start();
+  setInterval(async () => {
+    await updateTrackedProjectsCache(client);
+    try {
+      const cacheData = JSON.parse(readFileSync4(getTrackedProjectsCacheFile(), "utf-8"));
+      statusWriter.update({
+        trackedProjects: cacheData.projects || []
+      });
+    } catch {
+    }
+  }, 6e4);
   setInterval(() => cleanupStaleSessions(client), 3e5);
-  log("INFO", "Daemon started successfully \u2014 watching Claude conversations");
+  log("INFO", "Daemon started successfully \u2014 watching Claude conversations & skill usage");
   await new Promise(() => {
   });
 }