devpulse-ai 0.1.0

package/dist/config.js

@@ -0,0 +1,55 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+const CONFIG_DIR = join(homedir(), ".devpulse");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+const STATE_PATH = join(CONFIG_DIR, "state.json");
+/** Public dashboard URL (InsForge Deployments). */
+export const PRODUCTION_API_URL = "https://7aj5nkyd.insforge.site";
+const LEGACY_LOCAL_API_URL = "http://localhost:3000";
+const DEFAULT_API_URL = process.env.DEVPULSE_API_URL?.replace(/\/$/, "") || PRODUCTION_API_URL;
+function resolveApiUrl(stored) {
+    if (process.env.DEVPULSE_API_URL) {
+        return process.env.DEVPULSE_API_URL.replace(/\/$/, "");
+    }
+    // Upgrade configs that only ever had the old localhost default.
+    if (!stored || stored.replace(/\/$/, "") === LEGACY_LOCAL_API_URL) {
+        return DEFAULT_API_URL;
+    }
+    return stored.replace(/\/$/, "");
+}
+function ensureDir() {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_PATH))
+        return { apiUrl: DEFAULT_API_URL };
+    try {
+        const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+        return { ...parsed, apiUrl: resolveApiUrl(parsed.apiUrl) };
+    }
+    catch {
+        return { apiUrl: DEFAULT_API_URL };
+    }
+}
+export function saveConfig(config) {
+    ensureDir();
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function loadState() {
+    if (!existsSync(STATE_PATH))
+        return { sessions: {} };
+    try {
+        const parsed = JSON.parse(readFileSync(STATE_PATH, "utf8"));
+        return { sessions: parsed.sessions ?? {}, lastSyncAt: parsed.lastSyncAt };
+    }
+    catch {
+        return { sessions: {} };
+    }
+}
+export function saveState(state) {
+    ensureDir();
+    writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), { mode: 0o600 });
+}
+export const paths = { CONFIG_DIR, CONFIG_PATH, STATE_PATH };

package/dist/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { login } from "./commands/login.js";
+import { sync } from "./commands/sync.js";
+import { status } from "./commands/status.js";
+import { scheduleInstall, scheduleRemove, scheduleStatus } from "./commands/schedule.js";
+import { ui } from "./ui.js";
+const program = new Command();
+program
+    .name("devpulse")
+    .description("DevPulse AI — sync local AI coding sessions to your team dashboard.")
+    .version("0.1.0");
+program
+    .command("login")
+    .description("Authenticate the CLI (opens your browser by default).")
+    .option("--token <token>", "CLI token (skip browser login)")
+    .option("--no-browser", "Paste a token manually instead of opening the browser")
+    .option("--api-url <url>", "Override the dashboard URL")
+    .action(login);
+program
+    .command("sync")
+    .description("Scan local AI coding tool logs and upload new/changed sessions.")
+    .option("--dry-run", "Show what would be uploaded without sending anything")
+    .option("--force", "Re-sync all sessions, ignoring local dedupe state")
+    .option("--dir <path>", "Override the Claude Code projects directory")
+    .option("--tool <name>", "Only sync one tool (claude-code, codex, openclaw, cursor)")
+    .option("--limit <n>", "Only process up to N sessions", (v) => parseInt(v, 10))
+    .action(sync);
+program
+    .command("status")
+    .description("Show login state, detected tools, and pending sessions.")
+    .option("--dir <path>", "Override the Claude Code projects directory")
+    .option("--tool <name>", "Only show one tool (claude-code, codex, openclaw, cursor)")
+    .action(status);
+const schedule = program
+    .command("schedule")
+    .description("Install or manage automatic background sync (macOS launchd / Linux cron).");
+schedule
+    .command("install")
+    .description("Schedule `devpulse sync` to run automatically.")
+    .option("--every <hours>", "Run every N hours (1–24), e.g. --every 6")
+    .option("--daily", "Run once per day")
+    .option("--at <time>", "With --daily: local time HH:MM (default 09:00)")
+    .action(scheduleInstall);
+schedule
+    .command("status")
+    .description("Show the installed automatic sync schedule.")
+    .action(scheduleStatus);
+schedule
+    .command("remove")
+    .description("Uninstall automatic background sync.")
+    .action(scheduleRemove);
+program.parseAsync(process.argv).catch((err) => {
+    ui.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/parser/claude-code.js

@@ -0,0 +1,158 @@
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { buildSessionSummary } from "../summary.js";
+import { buildSummaryNotes, cleanUserText } from "../session-notes.js";
+const TOOL_NAME = "claude-code";
+/** Where Claude Code stores per-project session transcripts. */
+export function claudeProjectsDir() {
+    return process.env.CLAUDE_PROJECTS_DIR || join(homedir(), ".claude", "projects");
+}
+export function fingerprintFile(filePath) {
+    const st = statSync(filePath);
+    return `${Math.round(st.mtimeMs)}:${st.size}`;
+}
+/** Recursively list every `*.jsonl` transcript under the projects directory. */
+export function listSessionFiles(dir = claudeProjectsDir()) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    const walk = (d) => {
+        for (const entry of readdirSync(d, { withFileTypes: true })) {
+            const full = join(d, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+                out.push(full);
+        }
+    };
+    walk(dir);
+    return out;
+}
+function textFromContent(content) {
+    if (!content)
+        return null;
+    if (typeof content === "string")
+        return content;
+    const textPart = content.find((p) => p.type === "text" && p.text);
+    return textPart?.text ?? null;
+}
+function mostFrequent(values) {
+    if (values.length === 0)
+        return null;
+    const counts = new Map();
+    for (const v of values)
+        counts.set(v, (counts.get(v) ?? 0) + 1);
+    return [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+/**
+ * Parse a single transcript file into one session's metadata. Returns null if
+ * the file has no usable entries. Malformed lines are skipped, not fatal.
+ */
+export function parseSessionFile(filePath) {
+    const raw = readFileSync(filePath, "utf8");
+    const lines = raw.split("\n");
+    let sessionId = null;
+    let cwd = null;
+    let firstUserText = null;
+    let explicitSummary = null;
+    const userMessages = [];
+    let messageCount = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheCreationTokens = 0;
+    const models = [];
+    const timestamps = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(trimmed);
+        }
+        catch {
+            continue; // skip malformed line
+        }
+        if (entry.sessionId && !sessionId)
+            sessionId = entry.sessionId;
+        if (entry.cwd && !cwd)
+            cwd = entry.cwd;
+        if (entry.timestamp) {
+            const t = Date.parse(entry.timestamp);
+            if (!Number.isNaN(t))
+                timestamps.push(t);
+        }
+        if (entry.type === "summary" && entry.summary) {
+            explicitSummary = entry.summary;
+            continue;
+        }
+        const msg = entry.message;
+        if (entry.type === "user" && !entry.isMeta && msg) {
+            const text = textFromContent(msg.content);
+            if (text) {
+                const cleaned = cleanUserText(text);
+                if (cleaned) {
+                    userMessages.push(cleaned);
+                    if (!firstUserText)
+                        firstUserText = cleaned;
+                }
+            }
+            messageCount++;
+        }
+        else if (entry.type === "assistant" && msg) {
+            messageCount++;
+            if (msg.model)
+                models.push(msg.model);
+            const u = msg.usage;
+            if (u) {
+                inputTokens += u.input_tokens ?? 0;
+                outputTokens += u.output_tokens ?? 0;
+                cacheReadTokens += u.cache_read_input_tokens ?? 0;
+                cacheCreationTokens += u.cache_creation_input_tokens ?? 0;
+            }
+        }
+    }
+    // Fall back to the filename (which is the session uuid) for the dedupe key.
+    const externalId = sessionId ?? basename(filePath, ".jsonl");
+    if (messageCount === 0 && timestamps.length === 0)
+        return null;
+    const projectName = cwd ? basename(cwd) : decodeProjectDir(filePath);
+    const projectPathHash = cwd ? createHash("sha256").update(cwd).digest("hex").slice(0, 32) : null;
+    const startedAt = timestamps.length ? new Date(Math.min(...timestamps)).toISOString() : null;
+    const endedAt = timestamps.length ? new Date(Math.max(...timestamps)).toISOString() : null;
+    const summaryNotes = buildSummaryNotes({
+        tool: TOOL_NAME,
+        projectName,
+        title: explicitSummary,
+        userMessages,
+    });
+    const metadata = {
+        externalId,
+        tool: TOOL_NAME,
+        model: mostFrequent(models),
+        projectPathHash,
+        projectName,
+        summary: buildSessionSummary({ firstUserText, explicitSummary, projectName, messageCount }),
+        summaryNotes,
+        messageCount,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreationTokens,
+        startedAt,
+        endedAt,
+    };
+    return { metadata, filePath, fingerprint: fingerprintFile(filePath) };
+}
+/** Claude Code encodes the project path into the directory name (slashes -> dashes). */
+function decodeProjectDir(filePath) {
+    const parts = filePath.split("/");
+    const dirName = parts[parts.length - 2];
+    if (!dirName)
+        return null;
+    const segments = dirName.split("-").filter(Boolean);
+    return segments.length ? segments[segments.length - 1] : dirName;
+}

package/dist/schedule/install.js

@@ -0,0 +1,165 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { realpathSync, chmodSync, writeFileSync, unlinkSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { SCHEDULE_JOB_ID, SCHEDULE_LOG_PATH, SCHEDULE_MARKER, } from "./store.js";
+export function resolveCliExecutable() {
+    const entry = process.argv[1];
+    if (!entry)
+        throw new Error("Could not resolve the devpulse executable path.");
+    try {
+        return realpathSync(entry);
+    }
+    catch {
+        return entry;
+    }
+}
+function launchdPlistPath() {
+    return join(homedir(), "Library", "LaunchAgents", `${SCHEDULE_JOB_ID}.plist`);
+}
+function cronLine(cliPath, spec) {
+    const log = `${SCHEDULE_LOG_PATH}`;
+    if (spec.mode === "interval") {
+        const hours = spec.intervalHours ?? 6;
+        return `0 */${hours} * * * ${cliPath} sync >> ${log} 2>&1 ${SCHEDULE_MARKER}`;
+    }
+    const [hour, minute] = (spec.dailyAt ?? "09:00").split(":");
+    return `${minute} ${hour} * * * ${cliPath} sync >> ${log} 2>&1 ${SCHEDULE_MARKER}`;
+}
+function launchdPlist(cliPath, spec) {
+    const log = SCHEDULE_LOG_PATH;
+    const scheduleKey = spec.mode === "interval"
+        ? `<key>StartInterval</key>\n    <integer>${(spec.intervalHours ?? 6) * 3600}</integer>`
+        : (() => {
+            const [hour, minute] = (spec.dailyAt ?? "09:00").split(":").map((v) => parseInt(v, 10));
+            return `<key>StartCalendarInterval</key>
+    <dict>
+      <key>Hour</key>
+      <integer>${hour}</integer>
+      <key>Minute</key>
+      <integer>${minute}</integer>
+    </dict>`;
+        })();
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SCHEDULE_JOB_ID}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${cliPath}</string>
+    <string>sync</string>
+  </array>
+  ${scheduleKey}
+  <key>StandardOutPath</key>
+  <string>${log}</string>
+  <key>StandardErrorPath</key>
+  <string>${log}</string>
+</dict>
+</plist>
+`;
+}
+function readCrontab() {
+    try {
+        return execFileSync("crontab", ["-l"], { encoding: "utf8" });
+    }
+    catch (err) {
+        const e = err;
+        const stderr = e.stderr?.toString() ?? "";
+        if (stderr.includes("no crontab") || e.status === 1)
+            return "";
+        throw err;
+    }
+}
+function writeCrontab(content) {
+    execFileSync("crontab", ["-"], { input: content, encoding: "utf8" });
+}
+function stripDevpulseCronLines(crontab) {
+    return crontab
+        .split("\n")
+        .filter((line) => !line.includes(SCHEDULE_MARKER))
+        .join("\n")
+        .replace(/\n+$/, "");
+}
+function platform() {
+    if (process.platform === "darwin")
+        return "launchd";
+    if (process.platform === "linux")
+        return "cron";
+    return null;
+}
+function ensureExecutable(cliPath) {
+    try {
+        chmodSync(cliPath, 0o755);
+    }
+    catch {
+        /* ignore if chmod fails */
+    }
+}
+function installLaunchd(cliPath, spec) {
+    const plistPath = launchdPlistPath();
+    writeFileSync(plistPath, launchdPlist(cliPath, spec), { mode: 0o644 });
+    try {
+        execFileSync("launchctl", ["unload", plistPath], { stdio: "ignore" });
+    }
+    catch {
+        /* not loaded yet */
+    }
+    execFileSync("launchctl", ["load", "-w", plistPath]);
+}
+function removeLaunchd() {
+    const plistPath = launchdPlistPath();
+    if (!existsSync(plistPath))
+        return;
+    try {
+        execFileSync("launchctl", ["unload", plistPath], { stdio: "ignore" });
+    }
+    catch {
+        /* ignore */
+    }
+    unlinkSync(plistPath);
+}
+function installCron(cliPath, spec) {
+    const base = stripDevpulseCronLines(readCrontab());
+    const line = cronLine(cliPath, spec);
+    const next = base ? `${base}\n${line}\n` : `${line}\n`;
+    writeCrontab(next);
+}
+function removeCron() {
+    const base = stripDevpulseCronLines(readCrontab());
+    writeCrontab(base ? `${base}\n` : "");
+}
+export function installSchedule(spec) {
+    const cliPath = resolveCliExecutable();
+    const p = platform();
+    if (!p) {
+        throw new Error(`Automatic scheduling is not supported on ${process.platform}. Run \`devpulse sync\` manually or use your OS scheduler.`);
+    }
+    ensureExecutable(cliPath);
+    if (p === "launchd")
+        installLaunchd(cliPath, spec);
+    else
+        installCron(cliPath, spec);
+    return {
+        mode: spec.mode,
+        intervalHours: spec.intervalHours,
+        dailyAt: spec.dailyAt,
+        cliPath,
+        platform: p,
+        installedAt: new Date().toISOString(),
+    };
+}
+export function removeSchedule(config) {
+    const p = config?.platform ?? platform();
+    if (p === "launchd")
+        removeLaunchd();
+    else if (p === "cron")
+        removeCron();
+}
+export function describeSchedule(config) {
+    if (config.mode === "interval") {
+        return `every ${config.intervalHours ?? "?"} hour(s)`;
+    }
+    return `daily at ${config.dailyAt ?? "09:00"}`;
+}

package/dist/schedule/store.js

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from "node:fs";
+import { paths } from "../config.js";
+export const SCHEDULE_JOB_ID = "com.devpulse.sync";
+export const SCHEDULE_MARKER = "# devpulse-schedule";
+export const SCHEDULE_LOG_PATH = join(paths.CONFIG_DIR, "schedule.log");
+export const SCHEDULE_CONFIG_PATH = join(paths.CONFIG_DIR, "schedule.json");
+export function loadScheduleConfig() {
+    if (!existsSync(SCHEDULE_CONFIG_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(SCHEDULE_CONFIG_PATH, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveScheduleConfig(config) {
+    writeFileSync(SCHEDULE_CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function clearScheduleConfig() {
+    if (existsSync(SCHEDULE_CONFIG_PATH))
+        unlinkSync(SCHEDULE_CONFIG_PATH);
+}

package/dist/session-notes.js

@@ -0,0 +1,39 @@
+/** Strip transport/metadata wrappers so LLM sees the actual user intent. */
+export function cleanUserText(raw) {
+    if (!raw?.trim())
+        return null;
+    let text = raw.trim();
+    text = text.replace(/Sender\s*\([^)]*\):\s*```[\s\S]*?```/gi, "");
+    text = text.replace(/```json\s*\{[\s\S]*?\}\s*```/g, "");
+    text = text.replace(/<environment_context>[\s\S]*?<\/environment_context>/gi, "");
+    text = text.replace(/#\s*Context from my IDE setup:[\s\S]*?## My request for Codex:\s*/gi, "");
+    text = text.replace(/<user_query>\s*/g, "").replace(/<\/user_query>/g, "");
+    text = text.replace(/<[^>]+>/g, " ");
+    text = text.replace(/\[(Mon|Tue|Wed|Thu|Fri|Sat|Sun)[^\]]*\]\s*/g, "");
+    text = text.replace(/\s+/g, " ").trim();
+    if (text.length < 6)
+        return null;
+    if (/^openclaw-tui/i.test(text) && text.length < 40)
+        return null;
+    return text;
+}
+/** Lightweight context for server-side LLM session summaries (not stored in DB). */
+export function buildSummaryNotes(input) {
+    const messages = input.userMessages.map(cleanUserText).filter(Boolean);
+    const hasTitle = !!input.title?.trim();
+    if (messages.length === 0 && !hasTitle && !(input.files?.length))
+        return null;
+    const parts = [`Tool: ${input.tool}`];
+    if (input.projectName)
+        parts.push(`Project: ${input.projectName}`);
+    if (hasTitle)
+        parts.push(`Session title: ${input.title.trim()}`);
+    if (input.files?.length) {
+        parts.push(`Files edited: ${input.files.slice(0, 20).join(", ")}`);
+    }
+    if (messages.length) {
+        parts.push(`User requests:\n- ${messages.slice(0, 15).join("\n- ")}`);
+    }
+    const joined = parts.join("\n");
+    return joined.length > 8000 ? joined.slice(0, 7999).trimEnd() + "…" : joined;
+}

package/dist/summary.js

@@ -0,0 +1,25 @@
+/**
+ * Rule-based, session-level summary built locally during sync. No transcript
+ * content is uploaded — only this short derived string. An LLM-generated
+ * summary could replace this later behind the same signature.
+ */
+export function buildSessionSummary(input) {
+    const { firstUserText, explicitSummary, projectName, messageCount } = input;
+    // Prefer Claude Code's own "summary" entry when present.
+    if (explicitSummary && explicitSummary.trim()) {
+        return truncate(explicitSummary.trim(), 200);
+    }
+    if (firstUserText && firstUserText.trim()) {
+        const cleaned = firstUserText.replace(/\s+/g, " ").trim();
+        return truncate(cleaned, 200);
+    }
+    if (projectName) {
+        return `Worked in ${projectName} (${messageCount} messages).`;
+    }
+    return null;
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1).trimEnd() + "…";
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui.js

@@ -0,0 +1,21 @@
+import pc from "picocolors";
+import { createInterface } from "node:readline";
+export const ui = {
+    info: (msg) => console.log(msg),
+    success: (msg) => console.log(`${pc.green("✓")} ${msg}`),
+    warn: (msg) => console.log(`${pc.yellow("!")} ${msg}`),
+    error: (msg) => console.error(`${pc.red("✗")} ${msg}`),
+    dim: (msg) => console.log(pc.dim(msg)),
+    heading: (msg) => console.log(pc.bold(msg)),
+    pc,
+};
+/** Prompt for a single line of input (used for the login token). */
+export 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());
+        });
+    });
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "devpulse-ai",
+  "version": "0.1.0",
+  "description": "DevPulse AI CLI — sync local AI coding tool sessions to your team dashboard.",
+  "type": "module",
+  "bin": {
+    "devpulse": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/szy1840/dev_pulse.git",
+    "directory": "cli"
+  },
+  "homepage": "https://7aj5nkyd.insforge.site",
+  "bugs": {
+    "url": "https://github.com/szy1840/dev_pulse/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "claude-code",
+    "developer-tools",
+    "analytics",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^13.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.5",
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3"
+  }
+}