codiedev 0.3.4 → 0.3.6

package/dist/cli.js

@@ -22,6 +22,8 @@ const ping_1 = require("./commands/ping");
 const inbox_1 = require("./commands/inbox");
 const note_1 = require("./commands/note");
 const promote_1 = require("./commands/promote");
+const reverseTicket_1 = require("./commands/reverseTicket");
+const doctor_1 = require("./commands/doctor");
 const HELP = `
 CodieDev CLI
 
@@ -31,6 +33,7 @@ CodieDev CLI
 
 Connect:
   codiedev connect                       Link Claude Code / Codex to your org
+  codiedev doctor                        Verify your setup after connecting
 
 Artifacts:
   codiedev push <file.md>                Author or update an artifact
@@ -38,6 +41,8 @@ Artifacts:
                                          Fetch an artifact (stdout by default)
   codiedev promote <artifact-id>         Promote an auto-extracted artifact
                                          to an authored one
+  codiedev reverse-ticket <pr-url>       Generate a Jira ticket from a merged PR
+                                         (auto-matches spec + thread + transcript)
 
 Messaging:
   codiedev ping <user> "<msg>" [--with <key>]
@@ -311,6 +316,10 @@ async function main() {
             case "connect":
                 await (0, connect_1.runConnect)();
                 return;
+            case "doctor":
+            case "verify":
+                await (0, doctor_1.runDoctor)(rest);
+                return;
             case "push":
                 await (0, push_1.runPush)(rest);
                 return;
@@ -339,6 +348,10 @@ async function main() {
             case "promote":
                 await (0, promote_1.runPromote)(rest);
                 return;
+            case "reverse-ticket":
+            case "reverseTicket":
+                await (0, reverseTicket_1.runReverseTicket)(rest);
+                return;
             default:
                 console.error(`Unknown command: ${command}`);
                 console.error(HELP);

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function runDoctor(_args: string[]): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,263 @@
+"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.runDoctor = runDoctor;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const shared_1 = require("./shared");
+const utils_1 = require("../utils");
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+const CLAUDE_INSTRUCTIONS_PATH = path.join(os.homedir(), ".claude", "CLAUDE.md");
+const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
+const CODEX_INSTRUCTIONS_PATH = path.join(os.homedir(), ".codex", "AGENTS.md");
+function symbol(status) {
+    if (status === "pass")
+        return "✓";
+    if (status === "warn")
+        return "!";
+    return "✗";
+}
+function claudeCodeInstalled() {
+    return fs.existsSync(path.join(os.homedir(), ".claude"));
+}
+function codexInstalled() {
+    return fs.existsSync(path.join(os.homedir(), ".codex"));
+}
+function hasCodiedevHook(settingsPath, hookKey) {
+    try {
+        if (!fs.existsSync(settingsPath))
+            return false;
+        const raw = fs.readFileSync(settingsPath, "utf8");
+        const parsed = JSON.parse(raw);
+        const hooks = parsed.hooks?.[hookKey];
+        if (!Array.isArray(hooks))
+            return false;
+        return hooks.some((h) => {
+            const inner = h.hooks;
+            if (!Array.isArray(inner))
+                return false;
+            return inner.some((x) => (x.command ?? "").includes("codiedev-hook"));
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function hasCodiedevInstructions(instructionsPath) {
+    try {
+        if (!fs.existsSync(instructionsPath))
+            return false;
+        const raw = fs.readFileSync(instructionsPath, "utf8");
+        return raw.includes("codiedev-cli:begin");
+    }
+    catch {
+        return false;
+    }
+}
+function hasGhCli() {
+    try {
+        (0, child_process_1.execSync)("gh --version", { stdio: ["pipe", "pipe", "pipe"] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runDoctor(_args) {
+    const checks = [];
+    console.log("\nCodieDev doctor — checking your setup…\n");
+    // 1. Config file
+    const config = (0, utils_1.readConfig)();
+    if (!config) {
+        checks.push({
+            name: "CodieDev config (~/.codiedev/config.json)",
+            status: "fail",
+            detail: "Not found. Run `codiedev connect` first.",
+        });
+        report(checks);
+        process.exit(1);
+    }
+    checks.push({
+        name: "CodieDev config",
+        status: "pass",
+        detail: `connected to ${config.companyName}`,
+    });
+    // 2. Token still valid + backend reachable (re-validate)
+    try {
+        const res = await fetch(`${config.backendUrl}/api/cli/validateToken`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ token: config.token }),
+        });
+        if (res.ok) {
+            checks.push({
+                name: "Backend reachable + token valid",
+                status: "pass",
+            });
+        }
+        else {
+            checks.push({
+                name: "Backend reachable + token valid",
+                status: "fail",
+                detail: `HTTP ${res.status} — run \`codiedev connect\` with a fresh token`,
+            });
+        }
+    }
+    catch (err) {
+        checks.push({
+            name: "Backend reachable + token valid",
+            status: "fail",
+            detail: err.message,
+        });
+    }
+    // 3. Authenticated endpoint smoke test (inbox query)
+    try {
+        await (0, shared_1.apiRequest)("GET", "/api/cli/inbox", {
+            config,
+            query: { limit: 1 },
+        });
+        checks.push({
+            name: "Authenticated endpoint smoke test (`codiedev inbox`)",
+            status: "pass",
+        });
+    }
+    catch (err) {
+        checks.push({
+            name: "Authenticated endpoint smoke test",
+            status: "fail",
+            detail: err.message,
+        });
+    }
+    // 4. Tracked repos
+    const repoCount = config.repos?.length ?? 0;
+    checks.push({
+        name: "Tracked repos",
+        status: repoCount > 0 ? "pass" : "warn",
+        detail: repoCount > 0
+            ? `${repoCount} repo${repoCount === 1 ? "" : "s"}`
+            : "0 — link repos in the portal so sessions get captured",
+    });
+    // 5. Claude Code setup (if present)
+    if (claudeCodeInstalled()) {
+        checks.push({
+            name: "Claude Code detected",
+            status: "pass",
+            detail: "~/.claude",
+        });
+        checks.push({
+            name: "Claude Code SessionEnd hook",
+            status: hasCodiedevHook(CLAUDE_SETTINGS_PATH, "SessionEnd") ? "pass" : "fail",
+            detail: hasCodiedevHook(CLAUDE_SETTINGS_PATH, "SessionEnd")
+                ? "~/.claude/settings.json"
+                : "missing — re-run `codiedev connect`",
+        });
+        checks.push({
+            name: "Claude Code agent instructions",
+            status: hasCodiedevInstructions(CLAUDE_INSTRUCTIONS_PATH) ? "pass" : "fail",
+            detail: hasCodiedevInstructions(CLAUDE_INSTRUCTIONS_PATH)
+                ? "~/.claude/CLAUDE.md"
+                : "missing — re-run `codiedev connect`",
+        });
+    }
+    else {
+        checks.push({
+            name: "Claude Code",
+            status: "warn",
+            detail: "not installed on this machine",
+        });
+    }
+    // 6. Codex setup (if present)
+    if (codexInstalled()) {
+        checks.push({
+            name: "Codex detected",
+            status: "pass",
+            detail: "~/.codex",
+        });
+        checks.push({
+            name: "Codex Stop hook",
+            status: hasCodiedevHook(CODEX_HOOKS_PATH, "Stop") ? "pass" : "fail",
+            detail: hasCodiedevHook(CODEX_HOOKS_PATH, "Stop")
+                ? "~/.codex/hooks.json"
+                : "missing — re-run `codiedev connect`",
+        });
+        checks.push({
+            name: "Codex agent instructions",
+            status: hasCodiedevInstructions(CODEX_INSTRUCTIONS_PATH) ? "pass" : "fail",
+            detail: hasCodiedevInstructions(CODEX_INSTRUCTIONS_PATH)
+                ? "~/.codex/AGENTS.md"
+                : "missing — re-run `codiedev connect`",
+        });
+    }
+    else {
+        checks.push({
+            name: "Codex",
+            status: "warn",
+            detail: "not installed on this machine",
+        });
+    }
+    // 7. gh CLI (optional — only needed for reverse-ticket)
+    checks.push({
+        name: "GitHub CLI (`gh`) for reverse-ticket command",
+        status: hasGhCli() ? "pass" : "warn",
+        detail: hasGhCli()
+            ? "installed"
+            : "not installed — only needed if you use `codiedev reverse-ticket <pr-url>`",
+    });
+    report(checks);
+    const failures = checks.filter((c) => c.status === "fail");
+    if (failures.length > 0) {
+        process.exit(1);
+    }
+}
+function report(checks) {
+    for (const c of checks) {
+        const sym = symbol(c.status);
+        const line = c.detail ? `  ${sym} ${c.name} — ${c.detail}` : `  ${sym} ${c.name}`;
+        console.log(line);
+    }
+    const fails = checks.filter((c) => c.status === "fail").length;
+    const warns = checks.filter((c) => c.status === "warn").length;
+    const passes = checks.filter((c) => c.status === "pass").length;
+    console.log();
+    if (fails === 0) {
+        console.log(`All core checks passed (${passes} ok${warns > 0 ? `, ${warns} warning${warns === 1 ? "" : "s"}` : ""}). You're set.`);
+    }
+    else {
+        console.log(`${fails} check${fails === 1 ? "" : "s"} failed. Re-run \`codiedev connect\` or check your token at https://codiedev.com/portal/integrations/claude-code`);
+    }
+    console.log();
+}

package/dist/commands/reverseTicket.d.ts

@@ -0,0 +1 @@
+export declare function runReverseTicket(args: string[]): Promise<void>;

package/dist/commands/reverseTicket.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReverseTicket = runReverseTicket;
+const child_process_1 = require("child_process");
+const shared_1 = require("./shared");
+function parsePrUrl(url) {
+    const m = url.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+    if (!m)
+        return null;
+    return { owner: m[1], repo: m[2], number: Number(m[3]) };
+}
+function checkGhCli() {
+    try {
+        (0, child_process_1.execSync)("gh --version", { stdio: ["pipe", "pipe", "pipe"] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ghApi(path) {
+    const out = (0, child_process_1.execSync)(`gh api "${path}"`, {
+        stdio: ["pipe", "pipe", "pipe"],
+        maxBuffer: 50 * 1024 * 1024,
+    }).toString("utf8");
+    return JSON.parse(out);
+}
+function ghRaw(path) {
+    return (0, child_process_1.execSync)(`gh api -H "Accept: application/vnd.github.v3.diff" "${path}"`, {
+        stdio: ["pipe", "pipe", "pipe"],
+        maxBuffer: 50 * 1024 * 1024,
+    }).toString("utf8");
+}
+function parseArgs(args) {
+    let prUrl;
+    let forcedKey;
+    let noTruncate = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if ((a === "--with" || a === "-w") && i + 1 < args.length) {
+            forcedKey = args[++i];
+        }
+        else if (a.startsWith("--with=")) {
+            forcedKey = a.slice("--with=".length);
+        }
+        else if (a === "--full") {
+            noTruncate = true;
+        }
+        else if (!a.startsWith("--") && !prUrl) {
+            prUrl = a;
+        }
+    }
+    if (!prUrl) {
+        console.error("Usage: codiedev reverse-ticket <pr-url> [--with <artifact-key>] [--full]");
+        console.error("");
+        console.error("Example: codiedev reverse-ticket https://github.com/signalandcode/repo/pull/42");
+        process.exit(1);
+    }
+    return { prUrl, forcedKey, noTruncate };
+}
+async function runReverseTicket(args) {
+    const { prUrl, forcedKey, noTruncate } = parseArgs(args);
+    const parsed = parsePrUrl(prUrl);
+    if (!parsed) {
+        console.error("Couldn't parse PR URL. Expected format: https://github.com/<owner>/<repo>/pull/<number>");
+        process.exit(1);
+    }
+    if (!checkGhCli()) {
+        console.error("This command needs the `gh` CLI installed and authenticated.");
+        console.error("  brew install gh  (macOS)");
+        console.error("  gh auth login");
+        process.exit(1);
+    }
+    const config = (0, shared_1.requireConfig)();
+    console.log(`Fetching PR ${parsed.owner}/${parsed.repo}#${parsed.number}…`);
+    let prJson;
+    let filesJson;
+    let diff;
+    try {
+        prJson = ghApi(`/repos/${parsed.owner}/${parsed.repo}/pulls/${parsed.number}`);
+        filesJson = ghApi(`/repos/${parsed.owner}/${parsed.repo}/pulls/${parsed.number}/files`);
+        // Diff is nice-to-have; truncate if huge.
+        try {
+            const rawDiff = ghRaw(`/repos/${parsed.owner}/${parsed.repo}/pulls/${parsed.number}`);
+            diff = noTruncate ? rawDiff : rawDiff.slice(0, 12_000);
+        }
+        catch {
+            // Skip diff on failure — the writer works without it.
+        }
+    }
+    catch (err) {
+        console.error(`Failed to fetch PR via gh api: ${err.message}`);
+        process.exit(1);
+    }
+    const bundle = {
+        repo: `${parsed.owner}/${parsed.repo}`,
+        number: parsed.number,
+        title: prJson.title ?? "",
+        body: prJson.body ?? "",
+        author: prJson.user?.login ?? "unknown",
+        authorEmail: prJson.user?.email ?? undefined,
+        mergedAt: prJson.merged_at
+            ? Date.parse(prJson.merged_at)
+            : prJson.closed_at
+                ? Date.parse(prJson.closed_at)
+                : Date.now(),
+        filesChanged: (filesJson ?? []).map((f) => f.filename),
+        diff,
+        htmlUrl: prJson.html_url ?? prUrl,
+    };
+    console.log(`  title: ${bundle.title}`);
+    console.log(`  author: ${bundle.author}`);
+    console.log(`  files: ${bundle.filesChanged.length}`);
+    console.log(`  merged: ${new Date(bundle.mergedAt).toISOString()}`);
+    console.log("");
+    console.log("Generating ticket…");
+    console.log("");
+    try {
+        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/reverseTicket", {
+            config,
+            body: {
+                pr: bundle,
+                forcedArtifactKey: forcedKey,
+            },
+        });
+        if (res.match) {
+            console.log(`✓ Matched artifact: ${res.match.key} (score=${res.match.score.toFixed(2)})`);
+            console.log(`  signals · body=${res.match.signals.bodyMention} · files=${res.match.signals.fileOverlap.toFixed(2)} · transcript=${res.match.signals.transcriptEdit}`);
+        }
+        else if (res.candidates.length > 0) {
+            console.log(`? Ambiguous / low confidence. Candidates:`);
+            for (const c of res.candidates.slice(0, 3)) {
+                console.log(`  - ${c.key} (score=${c.score.toFixed(2)})`);
+            }
+            console.log(`  Re-run with --with <key> to force a specific artifact.`);
+        }
+        else {
+            console.log("· No matched artifact. Ticket generated from PR diff alone.");
+        }
+        console.log(`  prompt tokens (est): ${res.tokensInEstimate}`);
+        console.log("");
+        console.log("─────────── Generated ticket ───────────");
+        console.log("");
+        console.log(res.ticket);
+    }
+    catch (err) {
+        console.error(`Reverse-ticket failed: ${err.message}`);
+        process.exit(1);
+    }
+}

package/dist/connect.js

@@ -185,9 +185,9 @@ async function runConnect() {
         for (const target of installed) {
             console.log(`  - ${target}`);
         }
-        console.log("Sessions will be captured automatically.\n");
-    }
-    else {
-        console.log();
+        console.log("Sessions will be captured automatically.");
     }
+    console.log();
+    console.log("Run `codiedev doctor` to verify everything's wired up.");
+    console.log();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Connect Claude Code or Codex to CodieDev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "./dist/cli.js",