specrails-desktop 2.0.0

package/server/dist/core-compat.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCoreContract = findCoreContract;
+exports.detectCLISync = detectCLISync;
+exports.detectAvailableCLIs = detectAvailableCLIs;
+exports.detectCLI = detectCLI;
+exports.getCLIStatus = getCLIStatus;
+exports.checkCoreCompat = checkCoreCompat;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const setup_manager_1 = require("./setup-manager");
+// Windows has no `which`; probe PATH via `where` instead.
+const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
+// These must mirror KNOWN_VERBS in cli/specrails-desktop.ts
+const DESKTOP_KNOWN_COMMANDS = new Set([
+    'implement',
+    'batch-implement',
+    'why',
+    'product-backlog',
+    'update-product-driven-backlog',
+    'refactor-recommender',
+    'health-check',
+    'compat-check',
+    'enrich',
+]);
+async function findCoreContract() {
+    // Strategy 1: Try require.resolve (works for local installs)
+    try {
+        const contractPath = require.resolve('specrails-core/integration-contract.json');
+        if (fs_1.default.existsSync(contractPath))
+            return contractPath;
+    }
+    catch { /* not locally installed */ }
+    // Strategy 2: npm root -g
+    try {
+        const globalRoot = (0, child_process_1.execSync)('npm root -g', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim();
+        const contractPath = path_1.default.join(globalRoot, 'specrails-core', 'integration-contract.json');
+        if (fs_1.default.existsSync(contractPath))
+            return contractPath;
+    }
+    catch { /* npm not available or failed */ }
+    return null;
+}
+// ─── CLI detection ────────────────────────────────────────────────────────────
+// Importing the providers barrel registers every bundled adapter so the
+// detection helpers below walk the registry instead of hardcoding provider
+// ids. Detection order follows registration order (claude first, codex
+// second today) so behaviour is unchanged for existing callers that take
+// the first non-null result.
+const providers_1 = require("./providers");
+/**
+ * Synchronously detect the first AI CLI available in the user's PATH.
+ * Detection order is the registry order; today that means Claude before
+ * Codex. Returns null if no registered provider's CLI is found.
+ */
+function detectCLISync() {
+    for (const adapter of (0, providers_1.listAdapters)()) {
+        try {
+            (0, child_process_1.execSync)(`${WHICH_CMD} ${adapter.binary}`, { stdio: 'ignore' });
+            return adapter.id;
+        }
+        catch { /* keep looking */ }
+    }
+    return null;
+}
+/**
+ * Check which AI CLIs are available in the user's PATH. Returns a map of
+ * provider id → available flag, one entry per registered adapter.
+ */
+function detectAvailableCLIs() {
+    const out = {};
+    for (const adapter of (0, providers_1.listAdapters)()) {
+        try {
+            (0, child_process_1.execSync)(`${WHICH_CMD} ${adapter.binary}`, { stdio: 'ignore' });
+            out[adapter.id] = true;
+        }
+        catch {
+            out[adapter.id] = false;
+        }
+    }
+    return out;
+}
+/**
+ * Async wrapper around detectCLISync for callers that prefer Promise-based API.
+ */
+async function detectCLI() {
+    return detectCLISync();
+}
+/**
+ * Detect the active CLI and its version.
+ */
+function getCLIStatus() {
+    const provider = detectCLISync();
+    if (!provider)
+        return { provider: null, version: null };
+    try {
+        const versionFlag = '--version';
+        // Look up the binary name from the registry rather than using the
+        // provider id as the binary (they happen to match for claude/codex but
+        // future providers MAY split them).
+        const adapter = (0, providers_1.listAdapters)().find((a) => a.id === provider);
+        const binary = adapter?.binary ?? provider;
+        const raw = (0, child_process_1.execSync)(`${binary} ${versionFlag}`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+            timeout: 3000,
+        }).trim();
+        // Extract semver-like token from output (e.g. "Claude Code 1.2.3" → "1.2.3")
+        const match = raw.match(/\d+\.\d+\.\d+[\w.-]*/);
+        return { provider, version: match ? match[0] : raw };
+    }
+    catch {
+        return { provider, version: null };
+    }
+}
+function readDesktopVersion() {
+    // __dirname is server/ in dev (tsx) or server/dist/ when compiled
+    const candidates = [
+        path_1.default.join(__dirname, '..', 'package.json'), // from server/ (dev)
+        path_1.default.join(__dirname, '..', '..', 'package.json'), // from server/dist/ (compiled)
+    ];
+    for (const p of candidates) {
+        try {
+            const pkg = JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+            if (pkg.name === 'specrails-desktop' && pkg.version)
+                return pkg.version;
+        }
+        catch { /* skip */ }
+    }
+    return 'unknown';
+}
+async function checkCoreCompat() {
+    const desktopVersion = readDesktopVersion();
+    const contractPath = await findCoreContract();
+    if (!contractPath) {
+        return {
+            compatible: true,
+            coreVersion: null,
+            desktopVersion,
+            missingCheckpoints: [],
+            extraCheckpoints: [],
+            missingCommands: [],
+            extraCommands: [],
+            contractFound: false,
+        };
+    }
+    const contract = JSON.parse(fs_1.default.readFileSync(contractPath, 'utf-8'));
+    const desktopCheckpointKeys = setup_manager_1.CHECKPOINTS.map((cp) => cp.key);
+    // v1/v2 store checkpoints as a string[]; v3+ stores them as a description map.
+    const contractCheckpoints = Array.isArray(contract.checkpoints)
+        ? contract.checkpoints
+        : (contract.checkpoints && typeof contract.checkpoints === 'object'
+            ? Object.keys(contract.checkpoints)
+            : []);
+    const missingCheckpoints = contractCheckpoints.filter((c) => !desktopCheckpointKeys.includes(c));
+    const extraCheckpoints = desktopCheckpointKeys.filter((k) => !contractCheckpoints.includes(k));
+    // v3 dropped the `commands` field from the contract — when absent, the
+    // command-set check is a no-op (cannot prove drift either way).
+    const contractCommands = Array.isArray(contract.commands) ? contract.commands : [];
+    const missingCommands = contractCommands.filter((c) => !DESKTOP_KNOWN_COMMANDS.has(c));
+    const extraCommands = contract.commands === undefined
+        ? []
+        : [...DESKTOP_KNOWN_COMMANDS].filter((c) => !contractCommands.includes(c));
+    const compatible = missingCheckpoints.length === 0 &&
+        extraCheckpoints.length === 0 &&
+        missingCommands.length === 0 &&
+        extraCommands.length === 0;
+    return {
+        compatible,
+        coreVersion: contract.coreVersion ?? readCoreVersionNear(contractPath),
+        desktopVersion,
+        missingCheckpoints,
+        extraCheckpoints,
+        missingCommands,
+        extraCommands,
+        contractFound: true,
+        contractSchemaVersion: contract.schemaVersion,
+    };
+}
+// v3 contracts no longer include `coreVersion` at the top level — fall back
+// to reading it from the package.json next to the contract file.
+function readCoreVersionNear(contractPath) {
+    try {
+        let dir = path_1.default.dirname(contractPath);
+        for (let i = 0; i < 4; i++) {
+            const pkgPath = path_1.default.join(dir, 'package.json');
+            if (fs_1.default.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === 'specrails-core' && pkg.version)
+                    return pkg.version;
+            }
+            const parent = path_1.default.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}

package/server/dist/core-package.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_PACKAGE_SPEC = void 0;
+/**
+ * Single source of truth for the specrails-core npm package spec the app
+ * installs and probes (H5). Pinned to the current major range so a future
+ * specrails-core 5.x with breaking changes never lands on every user the
+ * minute it is published — adopting a new major is a deliberate one-line
+ * bump here, shipped through the app's own release pipeline.
+ *
+ * `SPECRAILS_CORE_BIN` remains the escape hatch for local/linked builds
+ * (see getCoreCommand in setup-manager.ts).
+ */
+exports.CORE_PACKAGE_SPEC = 'specrails-core@^4.6.0';