codiedev 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+# codiedev
+
+Connect Claude Code to CodieDev for org-wide session capture.
+
+## Usage
+
+```bash
+npx codiedev connect
+```
+
+The CLI will prompt you for an API token (get one at https://codiedev.com/portal/integrations/claude-code), then install a Claude Code `SessionEnd` hook that uploads transcripts from your tracked repos to your CodieDev workspace.
+
+## What gets captured
+
+- Only sessions inside repos your workspace already tracks
+- Transcript + basic stats (message count, tool calls)
+- Processed into summaries and embeddings server-side for search in `/portal/memories`
+
+## Config
+
+Written to `~/.codiedev/config.json`. The `SessionEnd` hook is added to `~/.claude/settings.json`.
+
+Override the backend with `CODIEDEV_URL` if needed.

package/dist/connect.d.ts

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

package/dist/connect.js

@@ -0,0 +1,157 @@
+#!/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 readline = __importStar(require("readline"));
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const utils_1 = require("./utils");
+const BACKEND_URL = process.env.CODIEDEV_URL || "https://judicious-falcon-861.convex.site";
+function prompt(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+function postJson(url, body) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const data = JSON.stringify(body);
+        const options = {
+            hostname: parsed.hostname,
+            port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(data),
+            },
+        };
+        const lib = parsed.protocol === "https:" ? https : http;
+        const req = lib.request(options, (res) => {
+            let responseData = "";
+            res.on("data", (chunk) => {
+                responseData += chunk;
+            });
+            res.on("end", () => {
+                try {
+                    const parsed = JSON.parse(responseData);
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(parsed);
+                    }
+                    else {
+                        reject(new Error(`HTTP ${res.statusCode}: ${parsed.error || responseData}`));
+                    }
+                }
+                catch {
+                    reject(new Error(`Failed to parse response: ${responseData}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(data);
+        req.end();
+    });
+}
+async function main() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log("\nWelcome to CodieDev CLI\n");
+    console.log("This will connect Claude Code to your CodieDev workspace and install");
+    console.log("the session capture hook for org-wide session sharing.\n");
+    let token;
+    try {
+        token = await prompt(rl, "Enter your CodieDev API token: ");
+    }
+    finally {
+        rl.close();
+    }
+    if (!token) {
+        console.error("Error: API token is required.");
+        process.exit(1);
+    }
+    console.log("\nValidating token...");
+    let responseData;
+    try {
+        responseData = await postJson(`${BACKEND_URL}/api/cli/validateToken`, {
+            token,
+        });
+    }
+    catch (err) {
+        console.error(`\nError: Failed to validate token — ${err.message}`);
+        process.exit(1);
+    }
+    // Extract fields from response
+    const companyId = responseData.companyId;
+    const companyName = responseData.companyName;
+    const repos = responseData.repos ?? [];
+    if (!companyId || !companyName) {
+        console.error("\nError: Invalid response from server. Token may be invalid.");
+        process.exit(1);
+    }
+    const config = {
+        token,
+        companyId,
+        companyName,
+        repos,
+        lastSynced: new Date().toISOString(),
+        backendUrl: BACKEND_URL,
+    };
+    try {
+        (0, utils_1.writeConfig)(config);
+    }
+    catch (err) {
+        console.error(`\nError: Failed to save config — ${err.message}`);
+        process.exit(1);
+    }
+    try {
+        (0, utils_1.installHook)();
+    }
+    catch (err) {
+        console.error(`\nWarning: Failed to install SessionEnd hook — ${err.message}`);
+        console.error("You can install it manually by adding npx codiedev-hook capture to your ~/.claude/settings.json hooks.");
+        // Don't exit — config was saved successfully
+    }
+    console.log(`\nConnected to ${companyName}`);
+    console.log(`Tracking ${repos.length} repo${repos.length === 1 ? "" : "s"}`);
+    console.log("SessionEnd hook installed — sessions will be captured automatically.\n");
+}
+main().catch((err) => {
+    console.error("Unexpected error:", err);
+    process.exit(1);
+});

package/dist/hook.d.ts

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

package/dist/hook.js

@@ -0,0 +1,195 @@
+#!/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 fs = __importStar(require("fs"));
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const utils_1 = require("./utils");
+function postJson(url, body, bearerToken) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const data = JSON.stringify(body);
+        const options = {
+            hostname: parsed.hostname,
+            port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(data),
+                Authorization: `Bearer ${bearerToken}`,
+            },
+        };
+        const lib = parsed.protocol === "https:" ? https : http;
+        const req = lib.request(options, (res) => {
+            let responseData = "";
+            res.on("data", (chunk) => {
+                responseData += chunk;
+            });
+            res.on("end", () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(data);
+        req.end();
+    });
+}
+function parseTranscriptStats(transcriptPath) {
+    let messageCount = 0;
+    let toolCallCount = 0;
+    try {
+        const content = fs.readFileSync(transcriptPath, "utf8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                if (!entry || typeof entry !== "object")
+                    continue;
+                // Claude Code transcript entries have type: "user" or "assistant" for messages
+                if (entry.type === "user" || entry.type === "assistant") {
+                    messageCount++;
+                }
+                // Tool calls live in the message.content array as blocks with type "tool_use"
+                const content = entry.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block && block.type === "tool_use") {
+                            toolCallCount++;
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+    }
+    catch {
+        // If we can't read/parse, return zeros
+    }
+    return { messageCount, toolCallCount };
+}
+async function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
+async function main() {
+    // Read hook input from stdin
+    let hookInput = {};
+    try {
+        const raw = await readStdin();
+        if (raw.trim()) {
+            hookInput = JSON.parse(raw);
+        }
+    }
+    catch {
+        // If stdin is malformed, exit silently
+        process.exit(0);
+    }
+    const { session_id, transcript_path, cwd } = hookInput;
+    // Read config — if missing, exit silently
+    const config = (0, utils_1.readConfig)();
+    if (!config) {
+        process.exit(0);
+    }
+    // Determine working directory
+    const workingDir = cwd || process.cwd();
+    // Get git remote URL for this directory
+    const remoteUrl = (0, utils_1.getGitRemoteUrl)(workingDir);
+    if (!remoteUrl) {
+        // Not a git repo or no remote — exit silently
+        process.exit(0);
+    }
+    // Check if this repo is in our tracked repos
+    const matchedRepo = (0, utils_1.matchRepo)(remoteUrl, config.repos);
+    if (!matchedRepo) {
+        // Repo not tracked — exit silently
+        process.exit(0);
+    }
+    // Validate transcript path
+    if (!transcript_path) {
+        process.exit(0);
+    }
+    // Read transcript file
+    let transcriptContent;
+    try {
+        transcriptContent = fs.readFileSync(transcript_path, "utf8");
+    }
+    catch {
+        // Can't read transcript — exit silently
+        process.exit(0);
+    }
+    // Parse transcript stats
+    const { messageCount, toolCallCount } = parseTranscriptStats(transcript_path);
+    // Base64 encode transcript
+    const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
+    // POST to backend
+    const payload = {
+        sessionId: session_id,
+        repoUrl: remoteUrl,
+        repoId: matchedRepo.repoId,
+        companyId: config.companyId,
+        transcript: transcriptBase64,
+        messageCount,
+        toolCallCount,
+        capturedAt: Date.now(),
+    };
+    try {
+        await postJson(`${config.backendUrl}/api/captureSession`, payload, config.token);
+    }
+    catch (err) {
+        // Write warning to stderr, but exit 0 — never block Claude Code
+        process.stderr.write(`[codiedev-hook] Warning: Failed to capture session — ${err.message}\n`);
+    }
+    process.exit(0);
+}
+main().catch(() => {
+    // Never block Claude Code on any error
+    process.exit(0);
+});

package/dist/utils.d.ts

@@ -0,0 +1,27 @@
+export interface CodiedevConfig {
+    token: string;
+    companyId: string;
+    companyName: string;
+    repos: Array<{
+        repoId: string;
+        url: string;
+        fullName: string;
+    }>;
+    lastSynced: string;
+    backendUrl: string;
+}
+export declare function readConfig(): CodiedevConfig | null;
+export declare function writeConfig(config: CodiedevConfig): void;
+export declare function getGitRemoteUrl(cwd: string): string | null;
+export declare function normalizeRepoUrl(url: string): string;
+export declare function matchRepo(remoteUrl: string, repos: Array<{
+    repoId: string;
+    url: string;
+    fullName: string;
+}>): {
+    repoId: string;
+    url: string;
+    fullName: string;
+} | null;
+export declare function hashToken(token: string): string;
+export declare function installHook(): void;

package/dist/utils.js

@@ -0,0 +1,175 @@
+"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.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.getGitRemoteUrl = getGitRemoteUrl;
+exports.normalizeRepoUrl = normalizeRepoUrl;
+exports.matchRepo = matchRepo;
+exports.hashToken = hashToken;
+exports.installHook = installHook;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const CONFIG_DIR = path.join(os.homedir(), ".codiedev");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+function readConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_PATH))
+            return null;
+        const raw = fs.readFileSync(CONFIG_PATH, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
+}
+function getGitRemoteUrl(cwd) {
+    try {
+        const url = (0, child_process_1.execSync)("git remote get-url origin", {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        })
+            .toString()
+            .trim();
+        return url || null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeRepoUrl(url) {
+    // Normalize SSH (git@github.com:org/repo.git) and HTTPS (https://github.com/org/repo.git)
+    // to a comparable form: github.com/org/repo
+    let normalized = url.trim();
+    // Strip trailing .git
+    if (normalized.endsWith(".git")) {
+        normalized = normalized.slice(0, -4);
+    }
+    // Handle SSH format: git@github.com:org/repo → github.com/org/repo
+    const sshMatch = normalized.match(/^git@([^:]+):(.+)$/);
+    if (sshMatch) {
+        return `${sshMatch[1]}/${sshMatch[2]}`;
+    }
+    // Handle HTTPS format: https://github.com/org/repo → github.com/org/repo
+    const httpsMatch = normalized.match(/^https?:\/\/(.+)$/);
+    if (httpsMatch) {
+        return httpsMatch[1];
+    }
+    return normalized;
+}
+function matchRepo(remoteUrl, repos) {
+    const normalizedRemote = normalizeRepoUrl(remoteUrl);
+    for (const repo of repos) {
+        const normalizedUrl = normalizeRepoUrl(repo.url);
+        const normalizedName = repo.fullName.toLowerCase();
+        if (normalizedRemote === normalizedUrl ||
+            normalizedRemote.endsWith(`/${normalizedName}`) ||
+            normalizedUrl.endsWith(`/${normalizedName}`)) {
+            return repo;
+        }
+    }
+    return null;
+}
+function hashToken(token) {
+    let hash = 0;
+    for (let i = 0; i < token.length; i++) {
+        const char = token.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return hash.toString(36);
+}
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+function installHook() {
+    let settings = {};
+    try {
+        if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+            const raw = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf8");
+            settings = JSON.parse(raw);
+        }
+    }
+    catch {
+        // Start with empty settings if file doesn't exist or is invalid
+    }
+    // Ensure hooks object exists
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    // Ensure SessionEnd array exists
+    if (!hooks.SessionEnd) {
+        hooks.SessionEnd = [];
+    }
+    const sessionEndHooks = hooks.SessionEnd;
+    // Check if codiedev-hook is already installed
+    const alreadyInstalled = sessionEndHooks.some((hook) => {
+        const matcher = hook.matcher;
+        const hooks2 = hook.hooks;
+        if (hooks2) {
+            return hooks2.some((h) => {
+                const cmd = h.command;
+                return cmd && cmd.includes("codiedev-hook");
+            });
+        }
+        return matcher && matcher.includes("codiedev-hook");
+    });
+    if (alreadyInstalled) {
+        return;
+    }
+    // Add the codiedev-hook capture entry
+    sessionEndHooks.push({
+        matcher: ".*",
+        hooks: [
+            {
+                type: "command",
+                command: "npx codiedev-hook capture",
+            },
+        ],
+    });
+    // Ensure directory exists
+    const settingsDir = path.dirname(CLAUDE_SETTINGS_PATH);
+    if (!fs.existsSync(settingsDir)) {
+        fs.mkdirSync(settingsDir, { recursive: true });
+    }
+    fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "codiedev",
+  "version": "0.1.0",
+  "description": "Connect Claude Code to CodieDev for org-wide session capture",
+  "bin": {
+    "codiedev": "./dist/connect.js",
+    "codiedev-hook": "./dist/hook.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "files": ["dist", "README.md"],
+  "keywords": [
+    "codiedev",
+    "claude-code",
+    "claude",
+    "ai",
+    "session-capture"
+  ],
+  "homepage": "https://codiedev.com",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^20.0.0"
+  }
+}