devpulse-ai 0.1.0

package/dist/adapters/index.js

@@ -0,0 +1,14 @@
+import { claudeCodeAdapter } from "./claude-code.js";
+import { codexAdapter } from "./codex.js";
+import { openclawAdapter } from "./openclaw.js";
+import { cursorAdapter } from "./cursor.js";
+/** All supported tool adapters, in display order. */
+export const adapters = [
+    claudeCodeAdapter,
+    codexAdapter,
+    openclawAdapter,
+    cursorAdapter,
+];
+export function getAdapter(tool) {
+    return adapters.find((a) => a.tool === tool);
+}

package/dist/adapters/openclaw.js

@@ -0,0 +1,167 @@
+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 = "openclaw";
+/** Root of OpenClaw's per-agent session transcripts. */
+function openclawAgentsDir() {
+    return process.env.OPENCLAW_HOME
+        ? join(process.env.OPENCLAW_HOME, "agents")
+        : join(homedir(), ".openclaw", "agents");
+}
+/** Active session transcripts: `<agents>/<agent>/sessions/*.jsonl`.
+ *  Archived files (`*.jsonl.reset.*`, `*.jsonl.deleted.*`) are skipped. */
+function listOpenclawSessions() {
+    const root = openclawAgentsDir();
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    for (const agent of readdirSync(root, { withFileTypes: true })) {
+        if (!agent.isDirectory())
+            continue;
+        const sessionsDir = join(root, agent.name, "sessions");
+        if (!existsSync(sessionsDir))
+            continue;
+        for (const entry of readdirSync(sessionsDir, { withFileTypes: true })) {
+            if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                out.push(join(sessionsDir, entry.name));
+            }
+        }
+    }
+    return out;
+}
+function textFromContent(content) {
+    if (!content)
+        return null;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        for (const part of content) {
+            if (part && typeof part === "object") {
+                const p = part;
+                if (p.text)
+                    return p.text;
+            }
+        }
+    }
+    return 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];
+}
+function parseOpenclawSession(filePath) {
+    const lines = readFileSync(filePath, "utf8").split("\n");
+    let sessionId = null;
+    let cwd = 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;
+        }
+        if (entry.type === "session") {
+            if (entry.id && !sessionId)
+                sessionId = entry.id;
+            if (entry.cwd && !cwd)
+                cwd = entry.cwd;
+        }
+        if (entry.type === "model_change" && entry.modelId)
+            models.push(entry.modelId);
+        if (entry.timestamp) {
+            const t = Date.parse(entry.timestamp);
+            if (!Number.isNaN(t))
+                timestamps.push(t);
+        }
+        const msg = entry.message;
+        if (entry.type === "message" && msg) {
+            messageCount++;
+            if (msg.role === "user") {
+                const text = textFromContent(msg.content);
+                if (text) {
+                    const cleaned = cleanUserText(text);
+                    if (cleaned)
+                        userMessages.push(cleaned);
+                }
+            }
+            if (msg.model)
+                models.push(msg.model);
+            const u = msg.usage;
+            if (u) {
+                inputTokens += u.input ?? 0;
+                outputTokens += u.output ?? 0;
+                cacheReadTokens += u.cacheRead ?? 0;
+                cacheCreationTokens += u.cacheWrite ?? 0;
+            }
+        }
+    }
+    const rawId = sessionId ?? basename(filePath, ".jsonl");
+    if (messageCount === 0 && timestamps.length === 0)
+        return null;
+    const projectName = cwd ? basename(cwd) : null;
+    const projectPathHash = cwd ? createHash("sha256").update(cwd).digest("hex").slice(0, 32) : null;
+    const firstUserText = userMessages[0] ?? null;
+    const summaryNotes = buildSummaryNotes({
+        tool: TOOL,
+        projectName,
+        userMessages,
+    });
+    return {
+        externalId: `${TOOL}:${rawId}`,
+        tool: TOOL,
+        model: mostFrequent(models),
+        projectPathHash,
+        projectName,
+        summary: buildSessionSummary({ firstUserText, explicitSummary: null, projectName, messageCount }),
+        summaryNotes,
+        messageCount,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreationTokens,
+        startedAt: timestamps.length ? new Date(Math.min(...timestamps)).toISOString() : null,
+        endedAt: timestamps.length ? new Date(Math.max(...timestamps)).toISOString() : null,
+    };
+}
+export const openclawAdapter = {
+    tool: TOOL,
+    label: "OpenClaw",
+    available() {
+        return existsSync(openclawAgentsDir());
+    },
+    discover() {
+        return listOpenclawSessions().map((file) => ({
+            stateKey: `${TOOL}:${file}`,
+            fingerprint: safeFingerprint(file),
+            load: () => parseOpenclawSession(file),
+        }));
+    },
+};
+function safeFingerprint(file) {
+    try {
+        const st = statSync(file);
+        return `${Math.round(st.mtimeMs)}:${st.size}`;
+    }
+    catch {
+        return "";
+    }
+}

package/dist/adapters/types.js

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

package/dist/api.js

@@ -0,0 +1,41 @@
+class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+async function request(config, path, body) {
+    if (!config.token)
+        throw new ApiError(401, "Not logged in. Run `devpulse login` first.");
+    const res = await fetch(new URL(path, config.apiUrl), {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${config.token}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        let detail = res.statusText;
+        try {
+            const json = (await res.json());
+            if (json.error)
+                detail = json.error;
+            if (json.details)
+                detail += `: ${JSON.stringify(json.details)}`;
+        }
+        catch {
+            /* ignore */
+        }
+        throw new ApiError(res.status, detail);
+    }
+    return (await res.json());
+}
+export function verifyToken(config) {
+    return request(config, "/api/cli/verify", {});
+}
+export function uploadSessions(config, sessions) {
+    return request(config, "/api/cli/sync", { sessions });
+}
+export { ApiError };

package/dist/browser-auth.js

@@ -0,0 +1,101 @@
+import { randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import http from "node:http";
+import os from "node:os";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const TIMEOUT_MS = 5 * 60_000;
+async function openBrowser(url) {
+    if (process.platform === "darwin") {
+        await execFileAsync("open", [url]);
+        return;
+    }
+    if (process.platform === "win32") {
+        await execFileAsync("cmd", ["/c", "start", "", url], { windowsHide: true });
+        return;
+    }
+    await execFileAsync("xdg-open", [url]);
+}
+function successHtml() {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="utf-8"><title>DevPulse CLI</title></head>
+<body style="font-family: system-ui, sans-serif; max-width: 32rem; margin: 4rem auto; padding: 0 1rem;">
+  <h1>DevPulse CLI connected</h1>
+  <p>You can close this tab and return to the terminal.</p>
+</body>
+</html>`;
+}
+function errorHtml(message) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="utf-8"><title>DevPulse CLI</title></head>
+<body style="font-family: system-ui, sans-serif; max-width: 32rem; margin: 4rem auto; padding: 0 1rem;">
+  <h1>Authorization failed</h1>
+  <p>${message}</p>
+  <p>Close this tab and run <code>devpulse login</code> again in the terminal.</p>
+</body>
+</html>`;
+}
+/** Start a localhost callback server, open the dashboard authorize page, wait for the token. */
+export function waitForBrowserAuth(apiUrl, onReady) {
+    const state = randomBytes(16).toString("hex");
+    const hostname = os.hostname();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timer;
+        function finish(err, result) {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            server.close();
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        }
+        const server = http.createServer((req, res) => {
+            if (!req.url?.startsWith("/callback")) {
+                res.writeHead(404);
+                res.end("Not found");
+                return;
+            }
+            const url = new URL(req.url, "http://127.0.0.1");
+            const token = url.searchParams.get("token");
+            const returnedState = url.searchParams.get("state");
+            if (!token || returnedState !== state) {
+                res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+                res.end(errorHtml("Invalid or missing authorization parameters."));
+                finish(new Error("Authorization callback rejected."));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            res.end(successHtml());
+            finish(null, { token });
+        });
+        server.on("error", (err) => finish(err));
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                finish(new Error("Could not start local callback server."));
+                return;
+            }
+            const port = addr.port;
+            const params = new URLSearchParams({
+                state,
+                port: String(port),
+                hostname,
+            });
+            const authUrl = `${apiUrl.replace(/\/$/, "")}/cli/authorize?${params}`;
+            onReady?.(authUrl);
+            openBrowser(authUrl).catch(() => {
+                // Browser open is best-effort; login prints the URL if needed.
+            });
+            timer = setTimeout(() => {
+                finish(new Error("Login timed out after 5 minutes. Run `devpulse login` again."));
+            }, TIMEOUT_MS);
+        });
+    });
+}

package/dist/commands/login.js

@@ -0,0 +1,60 @@
+import { loadConfig, saveConfig } from "../config.js";
+import { verifyToken, ApiError } from "../api.js";
+import { waitForBrowserAuth } from "../browser-auth.js";
+import { ui, prompt } from "../ui.js";
+async function loginWithBrowser(apiUrl) {
+    ui.info("Opening browser to log in…");
+    let authUrl = "";
+    const resultPromise = waitForBrowserAuth(apiUrl, (url) => {
+        authUrl = url;
+    });
+    // Give the local server a moment to bind and produce the URL.
+    await new Promise((r) => setTimeout(r, 150));
+    if (authUrl) {
+        ui.dim(`If the browser didn't open, visit:\n  ${authUrl}`);
+    }
+    const { token } = await resultPromise;
+    return token;
+}
+export async function login(opts) {
+    const config = loadConfig();
+    if (opts.apiUrl)
+        config.apiUrl = opts.apiUrl.replace(/\/$/, "");
+    ui.dim(`Dashboard: ${config.apiUrl}`);
+    let token = opts.token?.trim();
+    if (!token && opts.browser !== false) {
+        try {
+            token = (await loginWithBrowser(config.apiUrl)) ?? undefined;
+        }
+        catch (err) {
+            ui.warn(`Browser login failed: ${err.message}`);
+            ui.dim("You can paste a token from Settings instead.");
+        }
+    }
+    if (!token) {
+        token = await prompt(`Paste a CLI token (create one at ${config.apiUrl}/dashboard/settings):\n> `);
+    }
+    if (!token) {
+        ui.error("No token provided.");
+        process.exitCode = 1;
+        return;
+    }
+    config.token = token.trim();
+    try {
+        const res = await verifyToken(config);
+        config.user = res.user;
+        config.team = res.team;
+        saveConfig(config);
+        ui.success(`Logged in as ${res.user.name ?? res.user.email ?? res.user.id} → team "${res.team.name ?? res.team.id}".`);
+        ui.dim("Run `devpulse sync` to upload your AI coding sessions.");
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 401) {
+            ui.error("Token rejected. Double-check it was copied correctly and isn't revoked.");
+        }
+        else {
+            ui.error(`Login failed: ${err.message}`);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/commands/schedule.js

@@ -0,0 +1,95 @@
+import { existsSync } from "node:fs";
+import { loadConfig } from "../config.js";
+import { describeSchedule, installSchedule, removeSchedule } from "../schedule/install.js";
+import { clearScheduleConfig, loadScheduleConfig, saveScheduleConfig, SCHEDULE_LOG_PATH, } from "../schedule/store.js";
+import { ui } from "../ui.js";
+function parseIntervalHours(raw) {
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 1 || n > 24) {
+        throw new Error("--every must be an integer between 1 and 24 (hours).");
+    }
+    return n;
+}
+function parseDailyAt(raw) {
+    const value = raw ?? "09:00";
+    const m = /^(\d{1,2}):(\d{2})$/.exec(value);
+    if (!m)
+        throw new Error("Invalid --at time; use HH:MM in 24-hour format, e.g. 09:00.");
+    const hour = parseInt(m[1], 10);
+    const minute = parseInt(m[2], 10);
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+        throw new Error("Invalid --at time; hour must be 0–23 and minute 0–59.");
+    }
+    return `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+}
+function requireLogin() {
+    const config = loadConfig();
+    if (!config.token) {
+        ui.error("Not logged in. Run `devpulse login` before scheduling automatic sync.");
+        process.exitCode = 1;
+        return false;
+    }
+    return true;
+}
+export async function scheduleInstall(opts) {
+    if (!requireLogin())
+        return;
+    if (opts.every && opts.daily) {
+        ui.error("Use either --every <hours> or --daily, not both.");
+        process.exitCode = 1;
+        return;
+    }
+    if (!opts.every && !opts.daily) {
+        ui.error("Choose a schedule: --every <hours> or --daily [--at HH:MM].");
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const existing = loadScheduleConfig();
+        if (existing)
+            removeSchedule(existing);
+        const spec = opts.every
+            ? { mode: "interval", intervalHours: parseIntervalHours(opts.every) }
+            : { mode: "daily", dailyAt: parseDailyAt(opts.at) };
+        const config = installSchedule(spec);
+        saveScheduleConfig(config);
+        ui.success(`Automatic sync scheduled (${describeSchedule(config)}).`);
+        ui.dim(`Runs \`devpulse sync\` in the background via ${config.platform}.`);
+        ui.dim(`Logs: ${SCHEDULE_LOG_PATH}`);
+        ui.info("Run `devpulse schedule status` to inspect, or `devpulse schedule remove` to uninstall.");
+    }
+    catch (err) {
+        ui.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+}
+export async function scheduleStatus() {
+    const config = loadScheduleConfig();
+    ui.heading("DevPulse schedule");
+    if (!config) {
+        ui.warn("No automatic sync is installed.");
+        ui.dim("Install with `devpulse schedule install --every 6` or `devpulse schedule install --daily --at 09:00`.");
+        return;
+    }
+    ui.success(`Installed: ${describeSchedule(config)}`);
+    ui.info(`  Platform:  ${config.platform}`);
+    ui.info(`  CLI path:  ${config.cliPath}`);
+    ui.info(`  Installed: ${new Date(config.installedAt).toLocaleString()}`);
+    ui.info(`  Log file:  ${SCHEDULE_LOG_PATH}${existsSync(SCHEDULE_LOG_PATH) ? "" : " (not created yet)"}`);
+}
+export async function scheduleRemove() {
+    const config = loadScheduleConfig();
+    if (!config) {
+        ui.warn("No automatic sync is installed.");
+        return;
+    }
+    try {
+        removeSchedule(config);
+        clearScheduleConfig();
+        ui.success("Automatic sync removed.");
+    }
+    catch (err) {
+        ui.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,54 @@
+import { loadConfig, loadState, paths } from "../config.js";
+import { adapters, getAdapter } from "../adapters/index.js";
+import { ui } from "../ui.js";
+export async function status(opts = {}) {
+    const config = loadConfig();
+    const state = loadState();
+    ui.heading("DevPulse status");
+    ui.info(`  Dashboard:   ${config.apiUrl}`);
+    ui.info(`  Config file: ${paths.CONFIG_PATH}`);
+    if (config.token) {
+        const who = config.user?.name ?? config.user?.email ?? config.user?.id ?? "unknown";
+        ui.success(`  Logged in as ${who} → team "${config.team?.name ?? config.team?.id ?? "?"}"`);
+    }
+    else {
+        ui.warn("  Not logged in. Run `devpulse login`.");
+    }
+    let active = adapters;
+    if (opts.tool) {
+        const one = getAdapter(opts.tool);
+        if (!one) {
+            ui.error(`\n  Unknown tool "${opts.tool}". Supported: ${adapters.map((a) => a.tool).join(", ")}.`);
+            process.exitCode = 1;
+            return;
+        }
+        active = [one];
+    }
+    ui.info("\n  Tools:");
+    let totalPending = 0;
+    for (const adapter of active) {
+        if (!adapter.available({ dir: opts.dir })) {
+            ui.dim(`    ${adapter.label}: not detected`);
+            continue;
+        }
+        const discovered = adapter.discover({ dir: opts.dir });
+        let pending = 0;
+        for (const ds of discovered) {
+            const prev = state.sessions[ds.stateKey];
+            if (!prev || prev.fingerprint !== ds.fingerprint)
+                pending++;
+        }
+        totalPending += pending;
+        ui.info(`    ${adapter.label}: ${discovered.length} session(s), ${pending} pending`);
+    }
+    ui.info(`\n  Already synced:   ${Object.keys(state.sessions).length}`);
+    if (totalPending > 0) {
+        ui.warn(`  Pending sync:     ${totalPending} (run \`devpulse sync\`)`);
+    }
+    else {
+        ui.success("  Pending sync:     0 (up to date)");
+    }
+    if (state.lastSyncAt) {
+        ui.dim(`\n  Last sync: ${new Date(state.lastSyncAt).toLocaleString()}`);
+    }
+}

package/dist/commands/sync.js

@@ -0,0 +1,108 @@
+import { loadConfig, loadState, saveState } from "../config.js";
+import { adapters, getAdapter } from "../adapters/index.js";
+import { uploadSessions, ApiError } from "../api.js";
+import { ui } from "../ui.js";
+const BATCH_SIZE = 200;
+export async function sync(opts) {
+    const config = loadConfig();
+    if (!config.token) {
+        ui.error("Not logged in. Run `devpulse login` first.");
+        process.exitCode = 1;
+        return;
+    }
+    // Resolve which tools to scan.
+    let active = adapters;
+    if (opts.tool) {
+        const one = getAdapter(opts.tool);
+        if (!one) {
+            ui.error(`Unknown tool "${opts.tool}". Supported: ${adapters.map((a) => a.tool).join(", ")}.`);
+            process.exitCode = 1;
+            return;
+        }
+        active = [one];
+    }
+    const available = active.filter((a) => a.available({ dir: opts.dir }));
+    if (available.length === 0) {
+        ui.warn("No supported AI coding tools found on this machine.");
+        ui.dim(`Looked for: ${active.map((a) => a.label).join(", ")}.`);
+        return;
+    }
+    const state = loadState();
+    // Discover candidate sessions across every available tool (cheap fingerprints).
+    const pending = [];
+    let skipped = 0;
+    for (const adapter of available) {
+        let found = 0;
+        const discovered = adapter.discover({ dir: opts.dir });
+        for (const ds of discovered) {
+            found++;
+            const prev = state.sessions[ds.stateKey];
+            if (!opts.force && prev && prev.fingerprint === ds.fingerprint) {
+                skipped++;
+                continue;
+            }
+            pending.push(ds);
+        }
+        ui.dim(`Scanned ${adapter.label}: ${found} session(s).`);
+    }
+    // Parse only the new/changed ones (respecting --limit).
+    const toUpload = [];
+    for (const ds of pending) {
+        let metadata = null;
+        try {
+            metadata = ds.load();
+        }
+        catch {
+            /* skip unreadable/unparseable session */
+        }
+        if (metadata)
+            toUpload.push({ stateKey: ds.stateKey, fingerprint: ds.fingerprint, metadata });
+        if (opts.limit && toUpload.length >= opts.limit)
+            break;
+    }
+    ui.info(`${toUpload.length} new/changed session(s), ${skipped} unchanged (skipped)${opts.force ? " — forced full re-sync" : ""}.`);
+    if (toUpload.length === 0) {
+        ui.success("Everything is already up to date.");
+        return;
+    }
+    if (opts.dryRun) {
+        ui.heading("\nDry run — would upload:");
+        for (const { metadata: m } of toUpload.slice(0, 20)) {
+            ui.dim(`  • [${m.tool}] ${m.projectName ?? "?"} · ${m.model ?? "?"} · ${m.messageCount} msgs · ${m.inputTokens + m.outputTokens} tok`);
+        }
+        if (toUpload.length > 20)
+            ui.dim(`  …and ${toUpload.length - 20} more`);
+        ui.info("\nNothing uploaded (--dry-run).");
+        return;
+    }
+    let created = 0;
+    let updated = 0;
+    try {
+        for (let i = 0; i < toUpload.length; i += BATCH_SIZE) {
+            const batch = toUpload.slice(i, i + BATCH_SIZE);
+            const res = await uploadSessions(config, batch.map((b) => b.metadata));
+            created += res.created;
+            updated += res.updated;
+            // Persist fingerprints only after a successful batch upload.
+            const now = new Date().toISOString();
+            for (const b of batch) {
+                state.sessions[b.stateKey] = { fingerprint: b.fingerprint, lastSyncedAt: now };
+            }
+            saveState(state);
+        }
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 401) {
+            ui.error("Token rejected during sync. Run `devpulse login` again.");
+        }
+        else {
+            ui.error(`Sync failed: ${err.message}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    state.lastSyncAt = new Date().toISOString();
+    saveState(state);
+    ui.success(`Synced: ${created} new, ${updated} updated.`);
+    ui.dim(`View your team dashboard at ${config.apiUrl}/dashboard`);
+}