ccakashic 0.2.4 → 0.2.6

package/README.md

@@ -1,10 +1,14 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/ashimon83/ccakashic/main/assets/logo.png" alt="ccakashic logo" width="160" />
+</p>
+
 # ccakashic
 
 An Akashic Record of your Claude Code sessions — browse Claude Code session logs (`~/.claude/projects/`) as beautiful HTML in your browser.
 
-![Session detail with stats, cost badges, and chat layout](docs/screenshot1.png)
+![Session detail with stats, cost badges, and chat layout](https://raw.githubusercontent.com/ashimon83/ccakashic/main/docs/screenshot1.png)
 
-![Collapsible tool calls, code blocks, and per-message cost](docs/screenshot2.png)
+![Collapsible tool calls, code blocks, and per-message cost](https://raw.githubusercontent.com/ashimon83/ccakashic/main/docs/screenshot2.png)
 
 ## Usage
 

package/dist/bin/ccakashic.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const discover_1 = require("../discover");
+const parser_1 = require("../parser");
+const html_generator_1 = require("../html-generator");
+const pages_1 = require("../pages");
+// Published at dist/bin/ccakashic.js, so ../../package.json resolves from dist/
+const pkg = __importStar(require("../../package.json"));
+function openInBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'start'
+            : 'xdg-open';
+    (0, child_process_1.exec)(`${cmd} "${url}"`);
+}
+const PORT = parseInt(process.env.CCAKASHIC_PORT || '') || 3333;
+const MAX_PORT_TRIES = 20;
+const LOCK_FILE = path.join(os.tmpdir(), `ccakashic-${os.userInfo().username || 'user'}.json`);
+const server = http.createServer(async (req, res) => {
+    try {
+        const url = new URL(req.url || '/', `http://localhost`);
+        const pathname = url.pathname;
+        if (pathname === '/__ccakashic') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ name: 'ccakashic', version: pkg.version }));
+            return;
+        }
+        if (pathname === '/' || pathname === '') {
+            const projects = (0, discover_1.listProjects)();
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end((0, pages_1.generateIndex)(projects));
+            return;
+        }
+        const projectMatch = pathname.match(/^\/project\/(.+)$/);
+        if (projectMatch && !pathname.includes('/session/')) {
+            const rawName = decodeURIComponent(projectMatch[1]);
+            const projects = (0, discover_1.listProjects)();
+            const project = projects.find((p) => p.rawName === rawName);
+            if (!project) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Project not found');
+                return;
+            }
+            const sessions = await (0, discover_1.listSessions)(project.dir);
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end((0, pages_1.generateSessionList)(project, sessions));
+            return;
+        }
+        const sessionMatch = pathname.match(/^\/project\/(.+)\/session\/(.+)$/);
+        if (sessionMatch) {
+            const rawName = decodeURIComponent(sessionMatch[1]);
+            const sessionId = decodeURIComponent(sessionMatch[2]);
+            const projects = (0, discover_1.listProjects)();
+            const project = projects.find((p) => p.rawName === rawName);
+            if (!project) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Project not found');
+                return;
+            }
+            const sessionPath = path.join(project.dir, `${sessionId}.jsonl`);
+            if (!fs.existsSync(sessionPath)) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Session not found');
+                return;
+            }
+            const sessions = await (0, discover_1.listSessions)(project.dir);
+            const session = sessions.find((s) => s.id === sessionId) || { id: sessionId, path: sessionPath };
+            const parsed = await (0, parser_1.parseSession)(sessionPath);
+            const html = (0, html_generator_1.generate)(parsed, { projectName: project.name, session, backUrl: `/project/${encodeURIComponent(rawName)}` });
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(html);
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Not found');
+    }
+    catch (err) {
+        console.error(err);
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Internal server error');
+    }
+});
+async function buildOpenUrl(baseUrl) {
+    try {
+        const match = await (0, discover_1.findSessionForCwd)(process.cwd());
+        if (match) {
+            console.log(`Detected session for ${process.cwd()} → opening at bottom`);
+            return `${baseUrl}/project/${encodeURIComponent(match.projectRawName)}/session/${encodeURIComponent(match.sessionId)}#session-bottom`;
+        }
+    }
+    catch (err) {
+        console.error('Failed to auto-detect session:', err?.message);
+    }
+    return baseUrl;
+}
+function probeCcakashic(port) {
+    return new Promise((resolve) => {
+        const req = http.request({
+            host: '127.0.0.1',
+            port,
+            path: '/__ccakashic',
+            method: 'GET',
+            timeout: 500,
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    resolve(parsed && parsed.name === 'ccakashic');
+                }
+                catch {
+                    resolve(false);
+                }
+            });
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => { req.destroy(); resolve(false); });
+        req.end();
+    });
+}
+function readLockPort() {
+    try {
+        const data = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+        return typeof data.port === 'number' ? data.port : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeLockFile(port) {
+    try {
+        fs.writeFileSync(LOCK_FILE, JSON.stringify({ port, pid: process.pid, startedAt: Date.now() }));
+    }
+    catch {
+        // best-effort
+    }
+}
+function cleanupLockFile() {
+    try {
+        fs.unlinkSync(LOCK_FILE);
+    }
+    catch { }
+}
+function listenOnPort(port) {
+    return new Promise((resolve, reject) => {
+        const onError = (err) => { server.off('listening', onListening); reject(err); };
+        const onListening = () => { server.off('error', onError); resolve(); };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(port, '127.0.0.1');
+    });
+}
+async function findExistingCcakashic(startPort) {
+    const lockPort = readLockPort();
+    if (lockPort && await probeCcakashic(lockPort))
+        return lockPort;
+    if (startPort !== lockPort && await probeCcakashic(startPort))
+        return startPort;
+    return null;
+}
+async function startServer(startPort) {
+    for (let i = 0; i < MAX_PORT_TRIES; i++) {
+        const port = startPort + i;
+        try {
+            await listenOnPort(port);
+            return port;
+        }
+        catch (err) {
+            if (err?.code !== 'EADDRINUSE')
+                throw err;
+            if (await probeCcakashic(port))
+                return -port;
+        }
+    }
+    throw new Error(`No available port after ${MAX_PORT_TRIES} tries starting at ${startPort}`);
+}
+async function main() {
+    const existing = await findExistingCcakashic(PORT);
+    if (existing) {
+        const url = `http://127.0.0.1:${existing}`;
+        console.log(`Reusing existing ccakashic at ${url}`);
+        writeLockFile(existing);
+        openInBrowser(await buildOpenUrl(url));
+        return;
+    }
+    const result = await startServer(PORT);
+    if (result < 0) {
+        const port = -result;
+        const url = `http://127.0.0.1:${port}`;
+        console.log(`Reusing existing ccakashic at ${url}`);
+        writeLockFile(port);
+        openInBrowser(await buildOpenUrl(url));
+        return;
+    }
+    const port = result;
+    const url = `http://127.0.0.1:${port}`;
+    console.log(`ccakashic running at ${url}`);
+    console.log('Press Ctrl+C to stop');
+    writeLockFile(port);
+    const cleanup = () => { cleanupLockFile(); process.exit(0); };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    process.on('exit', cleanupLockFile);
+    openInBrowser(await buildOpenUrl(url));
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/discover.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_DIR = void 0;
+exports.decodeDirName = decodeDirName;
+exports.listProjects = listProjects;
+exports.listSessions = listSessions;
+exports.findSessionForCwd = findSessionForCwd;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+exports.CLAUDE_DIR = path.join(os.homedir(), '.claude', 'projects');
+function decodeDirName(dirName) {
+    // Directory names encode paths: /Users/foo/bar → -Users-foo-bar
+    // This is lossy (dots become dashes too), but good enough for display
+    if (dirName.startsWith('-')) {
+        return '/' + dirName.slice(1).replace(/-/g, '/');
+    }
+    return dirName;
+}
+function listProjects() {
+    if (!fs.existsSync(exports.CLAUDE_DIR)) {
+        return [];
+    }
+    const entries = fs.readdirSync(exports.CLAUDE_DIR, { withFileTypes: true });
+    const projects = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const projectDir = path.join(exports.CLAUDE_DIR, entry.name);
+        const jsonlFiles = fs.readdirSync(projectDir).filter((f) => f.endsWith('.jsonl'));
+        if (jsonlFiles.length === 0)
+            continue;
+        let lastModified = 0;
+        for (const f of jsonlFiles) {
+            const stat = fs.statSync(path.join(projectDir, f));
+            if (stat.mtimeMs > lastModified)
+                lastModified = stat.mtimeMs;
+        }
+        projects.push({
+            name: decodeDirName(entry.name),
+            rawName: entry.name,
+            dir: projectDir,
+            sessionCount: jsonlFiles.length,
+            lastModified: new Date(lastModified),
+        });
+    }
+    projects.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    return projects;
+}
+async function getSessionPreview(filePath) {
+    return new Promise((resolve) => {
+        const result = {
+            id: path.basename(filePath, '.jsonl'),
+            path: filePath,
+            timestamp: null,
+            lastModified: fs.statSync(filePath).mtimeMs,
+            preview: '',
+            gitBranch: null,
+            slug: null,
+            model: null,
+            hasSubagents: false,
+            totalTokens: 0,
+            outputTokens: 0,
+        };
+        const sessionDir = path.join(path.dirname(filePath), result.id);
+        if (fs.existsSync(path.join(sessionDir, 'subagents'))) {
+            result.hasSubagents = true;
+        }
+        const rl = readline.createInterface({
+            input: fs.createReadStream(filePath, { encoding: 'utf-8' }),
+            crlfDelay: Infinity,
+        });
+        let foundPreview = false;
+        rl.on('line', (line) => {
+            try {
+                const obj = JSON.parse(line);
+                if (!result.timestamp && obj.timestamp) {
+                    result.timestamp = obj.timestamp;
+                }
+                if (!result.gitBranch && obj.gitBranch) {
+                    result.gitBranch = obj.gitBranch;
+                }
+                if (!result.slug && obj.slug) {
+                    result.slug = obj.slug;
+                }
+                if (!result.model && obj.type === 'assistant' && obj.message?.model) {
+                    result.model = obj.message.model;
+                }
+                if (obj.type === 'assistant' && obj.message?.usage) {
+                    const u = obj.message.usage;
+                    result.totalTokens += (u.input_tokens || 0) + (u.output_tokens || 0)
+                        + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0);
+                    result.outputTokens += u.output_tokens || 0;
+                }
+                if (!foundPreview && obj.type === 'user' && obj.message) {
+                    const content = obj.message.content;
+                    let text = '';
+                    if (typeof content === 'string') {
+                        text = content;
+                    }
+                    else if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === 'text' && block.text) {
+                                text = block.text;
+                                break;
+                            }
+                        }
+                    }
+                    if (text) {
+                        result.preview = text.replace(/\n/g, ' ').slice(0, 100);
+                        foundPreview = true;
+                    }
+                }
+            }
+            catch {
+                // skip malformed lines
+            }
+        });
+        rl.on('close', () => resolve(result));
+        rl.on('error', () => resolve(result));
+    });
+}
+async function listSessions(projectDir) {
+    const jsonlFiles = fs
+        .readdirSync(projectDir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => path.join(projectDir, f));
+    const sessions = await Promise.all(jsonlFiles.map(getSessionPreview));
+    sessions.sort((a, b) => b.lastModified - a.lastModified);
+    return sessions;
+}
+function readCwdFromSession(filePath) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: fs.createReadStream(filePath, { encoding: 'utf-8' }),
+            crlfDelay: Infinity,
+        });
+        let found = null;
+        rl.on('line', (line) => {
+            if (found)
+                return;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.cwd) {
+                    found = obj.cwd;
+                    rl.close();
+                }
+            }
+            catch {
+                // skip
+            }
+        });
+        rl.on('close', () => resolve(found));
+        rl.on('error', () => resolve(found));
+    });
+}
+function latestSessionFile(projectDir) {
+    const files = fs.readdirSync(projectDir).filter((f) => f.endsWith('.jsonl'));
+    if (!files.length)
+        return null;
+    let best = null;
+    let bestMtime = 0;
+    for (const f of files) {
+        const mtime = fs.statSync(path.join(projectDir, f)).mtimeMs;
+        if (mtime > bestMtime) {
+            bestMtime = mtime;
+            best = f;
+        }
+    }
+    return best ? { file: best, mtimeMs: bestMtime } : null;
+}
+async function findSessionForCwd(cwd) {
+    // Pick the project whose cwd is the most specific (longest) match for the
+    // given cwd. A brand-new session in a specific subdir should win over an
+    // older, more-active ancestor project.
+    const projects = listProjects();
+    let bestMatch = null;
+    let bestLen = -1;
+    for (const project of projects) {
+        const latest = latestSessionFile(project.dir);
+        if (!latest)
+            continue;
+        const projectCwd = await readCwdFromSession(path.join(project.dir, latest.file));
+        if (!projectCwd)
+            continue;
+        const isMatch = cwd === projectCwd || cwd.startsWith(projectCwd + path.sep);
+        if (isMatch && projectCwd.length > bestLen) {
+            bestMatch = {
+                projectRawName: project.rawName,
+                sessionId: path.basename(latest.file, '.jsonl'),
+            };
+            bestLen = projectCwd.length;
+        }
+    }
+    return bestMatch;
+}