session-intelligence-cli 0.1.0

package/dist/api.d.ts

@@ -0,0 +1 @@
+export declare function sendEvent(payload: Record<string, unknown>): Promise<void>;

package/dist/api.js

@@ -0,0 +1,19 @@
+import { readConfig } from "./config.js";
+export async function sendEvent(payload) {
+    const config = readConfig();
+    if (!config)
+        return;
+    try {
+        await fetch(`${config.serverUrl}/api/events`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${config.apiKey}`,
+            },
+            body: JSON.stringify(payload),
+        });
+    }
+    catch {
+        // Silent — don't block Claude Code
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export interface Config {
+    apiKey: string;
+    serverUrl: string;
+}
+export declare function readConfig(): Config | null;
+export declare function writeConfig(config: Config): void;

package/dist/config.js

@@ -0,0 +1,16 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CONFIG_DIR = join(homedir(), ".session-intelligence");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function readConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return null;
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+}
+export function writeConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    chmodSync(CONFIG_FILE, 0o600);
+}

package/dist/git.d.ts

@@ -0,0 +1,13 @@
+export interface GitState {
+    branch: string;
+    lastCommitSha: string;
+    lastCommitMessage: string;
+    hasUncommittedChanges: boolean;
+}
+export interface GitDiffStats {
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+}
+export declare function readGitState(cwd: string): GitState | null;
+export declare function readGitDiffStats(cwd: string): GitDiffStats;

package/dist/git.js

@@ -0,0 +1,33 @@
+import { execSync } from "node:child_process";
+function run(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, encoding: "utf-8", timeout: 5000 }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+export function readGitState(cwd) {
+    const branch = run("git rev-parse --abbrev-ref HEAD", cwd);
+    if (!branch)
+        return null;
+    const logLine = run("git log -1 --format=%H%n%s", cwd);
+    const [sha = "", ...msgParts] = logLine.split("\n");
+    return {
+        branch,
+        lastCommitSha: sha,
+        lastCommitMessage: msgParts.join("\n"),
+        hasUncommittedChanges: run("git status --porcelain", cwd).length > 0,
+    };
+}
+export function readGitDiffStats(cwd) {
+    const stat = run("git diff --cached --shortstat", cwd) || run("git diff HEAD~1 --shortstat", cwd);
+    const files = stat.match(/(\d+) file/);
+    const ins = stat.match(/(\d+) insertion/);
+    const del = stat.match(/(\d+) deletion/);
+    return {
+        filesChanged: files ? parseInt(files[1]) : 0,
+        insertions: ins ? parseInt(ins[1]) : 0,
+        deletions: del ? parseInt(del[1]) : 0,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { report } from "./report.js";
+import { setup } from "./setup.js";
+import { status } from "./status.js";
+const [, , command, ...args] = process.argv;
+switch (command) {
+    case "report":
+        report(args[0] ?? "unknown").catch(() => process.exit(0));
+        break;
+    case "setup":
+        setup().catch((e) => {
+            console.error(e);
+            process.exit(1);
+        });
+        break;
+    case "status":
+        status().catch((e) => {
+            console.error(e);
+            process.exit(1);
+        });
+        break;
+    default:
+        console.log("Usage: session-intelligence <setup|report|status> [args]");
+        process.exit(1);
+}

package/dist/report.d.ts

@@ -0,0 +1 @@
+export declare function report(eventType: string): Promise<void>;

package/dist/report.js

@@ -0,0 +1,86 @@
+import { readFileSync } from "node:fs";
+import { readGitState, readGitDiffStats } from "./git.js";
+import { sendEvent } from "./api.js";
+const EVENT_MAP = {
+    "session-start": "SessionStart",
+    "stop": "Stop",
+    "session-end": "SessionEnd",
+    "tool-use": "PostToolUse",
+    "notification": "Notification",
+    "subagent-stop": "SubagentStop",
+};
+function parseTranscriptTokens(transcriptPath) {
+    const zero = { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_creation_tokens: 0 };
+    try {
+        const content = readFileSync(transcriptPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const entry = JSON.parse(trimmed);
+                if (entry.type !== "assistant" || !entry.message?.usage)
+                    continue;
+                const u = entry.message.usage;
+                zero.input_tokens += u.input_tokens ?? 0;
+                zero.output_tokens += u.output_tokens ?? 0;
+                zero.cache_read_tokens += u.cache_read_input_tokens ?? 0;
+                zero.cache_creation_tokens += u.cache_creation_input_tokens ?? 0;
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+    }
+    catch {
+        // file not found or unreadable
+    }
+    return zero;
+}
+export async function report(eventType) {
+    let stdinData = {};
+    try {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        const raw = Buffer.concat(chunks).toString("utf-8").trim();
+        if (raw)
+            stdinData = JSON.parse(raw);
+    }
+    catch {
+        // No stdin or invalid JSON
+    }
+    const sessionId = stdinData.session_id ?? "";
+    const cwd = stdinData.cwd ?? process.cwd();
+    const payload = {
+        session_id: sessionId,
+        cwd,
+        hook_event_name: EVENT_MAP[eventType] ?? eventType,
+        model: stdinData.model,
+        tool_name: stdinData.tool_name,
+    };
+    if (eventType === "session-end") {
+        const transcriptPath = stdinData.transcript_path;
+        if (transcriptPath) {
+            payload.usage = parseTranscriptTokens(transcriptPath);
+        }
+    }
+    const git = readGitState(cwd);
+    if (git) {
+        const gitPayload = {
+            branch: git.branch,
+            lastCommitSha: git.lastCommitSha,
+            lastCommitMessage: git.lastCommitMessage,
+            hasUncommittedChanges: git.hasUncommittedChanges,
+        };
+        if (eventType === "stop" || eventType === "session-end") {
+            const stats = readGitDiffStats(cwd);
+            gitPayload.filesChanged = stats.filesChanged;
+            gitPayload.insertions = stats.insertions;
+            gitPayload.deletions = stats.deletions;
+        }
+        payload.git = gitPayload;
+    }
+    await sendEvent(payload);
+}

package/dist/setup.d.ts

@@ -0,0 +1 @@
+export declare function setup(): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,61 @@
+import { createInterface } from "node:readline";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { writeConfig } from "./config.js";
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+const HOOKS_CONFIG = {
+    SessionStart: [{ type: "command", command: "npx session-intelligence-cli report session-start" }],
+    Stop: [{ type: "command", command: "npx session-intelligence-cli report stop" }],
+    PostToolUse: [{ type: "command", command: "npx session-intelligence-cli report tool-use", timeout: 3000 }],
+    Notification: [{ type: "command", command: "npx session-intelligence-cli report notification" }],
+    SubagentStop: [{ type: "command", command: "npx session-intelligence-cli report subagent-stop", timeout: 3000 }],
+};
+export async function setup() {
+    console.log("\n  Session Intelligence — Setup\n");
+    const serverUrl = await prompt("  Server URL (e.g. https://your-app.vercel.app): ");
+    const apiKey = await prompt("  API Key: ");
+    writeConfig({ apiKey, serverUrl });
+    console.log("\n  Config saved to ~/.session-intelligence/config.json");
+    try {
+        const res = await fetch(`${serverUrl}/api/health`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        console.log("  Server connection verified");
+    }
+    catch (e) {
+        console.warn(`  Warning: Could not reach server (${e}). Check URL and try again.`);
+    }
+    const claudeSettingsPath = join(homedir(), ".claude", "settings.json");
+    let settings = {};
+    if (existsSync(claudeSettingsPath)) {
+        settings = JSON.parse(readFileSync(claudeSettingsPath, "utf-8"));
+    }
+    const existingHooks = (settings.hooks ?? {});
+    for (const [event, handlers] of Object.entries(HOOKS_CONFIG)) {
+        const existing = existingHooks[event] ?? [];
+        const alreadyInstalled = existing.some((h) => typeof h === "object" &&
+            h !== null &&
+            "command" in h &&
+            h.command.includes("session-intelligence"));
+        if (!alreadyInstalled) {
+            existingHooks[event] = [...existing, ...handlers];
+        }
+    }
+    settings.hooks = existingHooks;
+    mkdirSync(dirname(claudeSettingsPath), { recursive: true });
+    writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2));
+    console.log("  Claude Code hooks installed to ~/.claude/settings.json");
+    console.log("\n  Done! Your next Claude Code session will start reporting.\n");
+}

package/dist/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/status.js

@@ -0,0 +1,63 @@
+import { readConfig } from "./config.js";
+const STATUS_DISPLAY = {
+    thinking: { icon: "\u25CF", label: "thinking", color: "\x1b[32m" },
+    needs_input: { icon: "\u25D0", label: "needs_input", color: "\x1b[33m" },
+    idle: { icon: "\u25CB", label: "idle", color: "\x1b[90m" },
+    archived: { icon: "\u25CB", label: "archived", color: "\x1b[90m" },
+};
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+function timeAgo(timestamp) {
+    const seconds = Math.floor((Date.now() - timestamp) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+export async function status() {
+    const config = readConfig();
+    if (!config) {
+        console.error("Not configured. Run: session-intelligence setup");
+        process.exit(1);
+    }
+    let data;
+    try {
+        const res = await fetch(`${config.serverUrl}/api/sessions`, {
+            headers: { Authorization: `Bearer ${config.apiKey}` },
+        });
+        if (!res.ok) {
+            console.error(`Server returned ${res.status}`);
+            process.exit(1);
+        }
+        data = (await res.json());
+    }
+    catch {
+        console.error("Could not reach server");
+        process.exit(1);
+    }
+    const { sessions, limited } = data;
+    console.log(`${BOLD}Sessions (${sessions.length})${RESET}`);
+    console.log();
+    if (sessions.length === 0) {
+        console.log(`  ${DIM}No active sessions${RESET}`);
+        console.log();
+        return;
+    }
+    for (const s of sessions) {
+        const display = STATUS_DISPLAY[s.status] ?? STATUS_DISPLAY.idle;
+        const branch = s.gitBranch ? `${DIM}${s.gitBranch}${RESET}` : "";
+        const ago = timeAgo(s.lastEventAt);
+        console.log(`  ${display.color}${display.icon} ${display.label}${RESET}  ${s.project}  ${branch}  ${DIM}${ago}${RESET}`);
+    }
+    if (limited) {
+        console.log();
+        console.log(`${DIM}More sessions available — upgrade to Pro${RESET}`);
+    }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "session-intelligence-cli",
+  "version": "0.1.0",
+  "description": "CLI plugin for Session Intelligence — hooks into Claude Code to track sessions",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xleal/personal-dashboard.git",
+    "directory": "cli"
+  },
+  "bin": {
+    "session-intelligence": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}