specrails-desktop 2.0.0

package/server/dist/context-budget.js

@@ -0,0 +1,113 @@
+"use strict";
+// Context budget — coarse token estimates for the four Add Spec context scopes.
+// Powers the live numeric line in the Cost Awareness meter.
+//
+// Estimates are bytes/4 (ASCII heuristic). Codebase walk respects common
+// ignore patterns (node_modules, .git, dist, build) but does not parse
+// .gitignore — keeping it cheap and fast.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearContextBudgetCache = clearContextBudgetCache;
+exports.computeContextBudget = computeContextBudget;
+exports.getContextBudget = getContextBudget;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const context_scope_1 = require("./context-scope");
+const BYTES_PER_TOKEN = 4;
+const CACHE_TTL_MS = 60_000;
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', '.turbo',
+    'coverage', '.cache', 'tmp', '.specrails',
+]);
+const SOURCE_EXT = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.md', '.json', '.css', '.scss', '.html',
+    '.py', '.rb', '.go', '.rs', '.java', '.kt', '.swift',
+    '.c', '.cc', '.cpp', '.h', '.hpp', '.cs',
+]);
+const cache = new Map();
+function clearContextBudgetCache(projectId) {
+    if (projectId)
+        cache.delete(projectId);
+    else
+        cache.clear();
+}
+function walkCodebase(root) {
+    if (!node_fs_1.default.existsSync(root))
+        return { fileCount: 0, bytes: 0 };
+    let fileCount = 0;
+    let bytes = 0;
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (SKIP_DIRS.has(e.name))
+                continue;
+            if (e.name.startsWith('.') && e.name !== '.specrails-skip-marker')
+                continue;
+            const full = node_path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                stack.push(full);
+            }
+            else if (e.isFile()) {
+                const ext = node_path_1.default.extname(e.name).toLowerCase();
+                if (!SOURCE_EXT.has(ext))
+                    continue;
+                try {
+                    bytes += node_fs_1.default.statSync(full).size;
+                    fileCount += 1;
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    return { fileCount, bytes };
+}
+function readMcpServers(projectPath) {
+    const file = node_path_1.default.join(projectPath, '.mcp.json');
+    if (!node_fs_1.default.existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+        return parsed.mcpServers ? Object.keys(parsed.mcpServers).sort() : [];
+    }
+    catch {
+        return [];
+    }
+}
+function bytesOfSection(section) {
+    return section ? Buffer.byteLength(section, 'utf8') : 0;
+}
+function computeContextBudget(projectPath) {
+    // Use the same builders the spawn path uses — token estimates reflect what
+    // will actually land in the system prompt (caps + formatting included), not
+    // the raw on-disk byte count of source files.
+    const ticketsBytes = bytesOfSection((0, context_scope_1.buildSpecrailsTicketsSection)(projectPath));
+    const openspecBytes = bytesOfSection((0, context_scope_1.buildOpenSpecSpecsSection)(projectPath));
+    const { fileCount, bytes: codebaseBytes } = walkCodebase(projectPath);
+    return {
+        specrailsTicketsTokens: Math.round(ticketsBytes / BYTES_PER_TOKEN),
+        openspecSpecsTokens: Math.round(openspecBytes / BYTES_PER_TOKEN),
+        codebaseFileCount: fileCount,
+        codebaseEstimatedTokens: Math.round(codebaseBytes / BYTES_PER_TOKEN),
+        mcpServers: readMcpServers(projectPath),
+    };
+}
+function getContextBudget(projectId, projectPath) {
+    const now = Date.now();
+    const hit = cache.get(projectId);
+    if (hit && hit.expiresAt > now)
+        return hit.value;
+    const value = computeContextBudget(projectPath);
+    cache.set(projectId, { value, expiresAt: now + CACHE_TTL_MS });
+    return value;
+}

package/server/dist/context-scope.js

@@ -0,0 +1,279 @@
+"use strict";
+// Context Scope — per-spec configuration that controls what context is fed
+// into the Add Spec flow (Quick `generate-spec` and Explore chat turns).
+//
+// Four orthogonal toggles:
+//   - specrails: concat <project>/.specrails/local-tickets.json (all tickets)
+//                into the system prompt
+//   - openspec:  concat <project>/openspec/specs/**/spec.md into the system prompt
+//   - full:      allow Read/Grep/Glob (Bash is never auto-allowed)
+//   - mcp:       Explore-only — spawn from <project> so .mcp.json is honored
+//   - userMcp:   Explore-only — inject the user's own already-approved MCP
+//                servers (claude: ~/.claude.json user+local scope, fed via
+//                `--mcp-config`; codex: ~/.codex is read natively). Independent
+//                of `mcp` (project `.mcp.json`) and does NOT change the spawn cwd.
+//
+// Persistence: `queue_state.add_spec_context_scope_last` (per-project) holds
+// the last-used scope. `chat_conversations.context_scope` (per-conversation,
+// JSON) freezes the scope at the conversation's creation time.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BYTES_PER_TOKEN = exports.SPEC_CONCAT_TOKEN_CAP = void 0;
+exports.defaultBootScope = defaultBootScope;
+exports.normalizeContextScope = normalizeContextScope;
+exports.getLastContextScope = getLastContextScope;
+exports.setLastContextScope = setLastContextScope;
+exports.setConversationContextScope = setConversationContextScope;
+exports.getConversationContextScope = getConversationContextScope;
+exports.buildSpecrailsTicketsSection = buildSpecrailsTicketsSection;
+exports.buildOpenSpecSpecsSection = buildOpenSpecSpecsSection;
+exports.buildScopedSystemPromptPrefix = buildScopedSystemPromptPrefix;
+exports.toolFlagsForScope = toolFlagsForScope;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// Maximum tokens worth of concatenated spec content injected per section
+// (specrails + openspec each get their own 30k budget).
+exports.SPEC_CONCAT_TOKEN_CAP = 30_000;
+// Rough heuristic: ASCII text averages ~4 bytes per token.
+exports.BYTES_PER_TOKEN = 4;
+function defaultBootScope(mode) {
+    return {
+        specrails: true,
+        openspec: false,
+        full: mode === 'explore',
+        mcp: false,
+        contractRefine: false,
+        userMcp: false,
+    };
+}
+// Shape-validate an unknown value into a ContextScope. Unknown keys are
+// dropped; non-boolean values fall back to `fallback` per key.
+function normalizeContextScope(value, fallback) {
+    if (!value || typeof value !== 'object')
+        return { ...fallback };
+    const v = value;
+    return {
+        specrails: typeof v.specrails === 'boolean' ? v.specrails : fallback.specrails,
+        openspec: typeof v.openspec === 'boolean' ? v.openspec : fallback.openspec,
+        full: typeof v.full === 'boolean' ? v.full : fallback.full,
+        mcp: typeof v.mcp === 'boolean' ? v.mcp : fallback.mcp,
+        contractRefine: typeof v.contractRefine === 'boolean' ? v.contractRefine : fallback.contractRefine,
+        userMcp: typeof v.userMcp === 'boolean' ? v.userMcp : (fallback.userMcp ?? false),
+    };
+}
+function getLastContextScope(db, mode = 'explore') {
+    const row = db.prepare(`SELECT value FROM queue_state WHERE key = 'add_spec_context_scope_last'`).get();
+    const fallback = defaultBootScope(mode);
+    if (!row?.value)
+        return fallback;
+    try {
+        return normalizeContextScope(JSON.parse(row.value), fallback);
+    }
+    catch {
+        return fallback;
+    }
+}
+function setLastContextScope(db, scope) {
+    const value = JSON.stringify({
+        specrails: !!scope.specrails,
+        openspec: !!scope.openspec,
+        full: !!scope.full,
+        mcp: !!scope.mcp,
+        contractRefine: !!scope.contractRefine,
+        userMcp: !!scope.userMcp,
+    });
+    db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('add_spec_context_scope_last', ?)`).run(value);
+}
+function setConversationContextScope(db, conversationId, scope) {
+    db.prepare(`UPDATE chat_conversations SET context_scope = ? WHERE id = ?`).run(JSON.stringify(scope), conversationId);
+}
+function getConversationContextScope(db, conversationId) {
+    const row = db.prepare(`SELECT context_scope FROM chat_conversations WHERE id = ?`).get(conversationId);
+    if (!row?.context_scope)
+        return null;
+    try {
+        const parsed = JSON.parse(row.context_scope);
+        return normalizeContextScope(parsed, {
+            specrails: false, openspec: false, full: true, mcp: false, contractRefine: false, userMcp: false,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function walkMdFiles(root, predicate) {
+    if (!node_fs_1.default.existsSync(root))
+        return [];
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = node_path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (e.name.startsWith('.') && e.name !== '.specrails')
+                    continue;
+                if (e.name === 'node_modules')
+                    continue;
+                stack.push(full);
+            }
+            else if (e.isFile() && e.name.endsWith('.md')) {
+                const rel = node_path_1.default.relative(root, full);
+                if (predicate(rel))
+                    out.push(full);
+            }
+        }
+    }
+    out.sort();
+    return out;
+}
+function concatFilesWithCap(files, byteCap) {
+    let total = 0;
+    const parts = [];
+    let truncated = false;
+    for (const file of files) {
+        let content;
+        try {
+            content = node_fs_1.default.readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const header = `### ${node_path_1.default.basename(file)}\n\n`;
+        const piece = `${header}${content}\n\n`;
+        const pieceBytes = Buffer.byteLength(piece);
+        if (total + pieceBytes > byteCap) {
+            const remaining = Math.max(0, byteCap - total);
+            if (remaining > 0) {
+                parts.push(piece.slice(0, remaining));
+                total = byteCap;
+            }
+            truncated = true;
+            break;
+        }
+        parts.push(piece);
+        total += pieceBytes;
+    }
+    return { text: parts.join(''), truncated, bytes: total };
+}
+// Format the project's local-tickets.json store as a markdown section. ALL
+// tickets are included (no status filter). Capped at 30k tokens worth of
+// bytes; overflow ends with a `(truncated)` marker.
+function buildSpecrailsTicketsSection(projectPath) {
+    const file = node_path_1.default.join(projectPath, '.specrails', 'local-tickets.json');
+    if (!node_fs_1.default.existsSync(file))
+        return null;
+    let raw;
+    try {
+        raw = node_fs_1.default.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    // Ticket store schemas seen in the wild:
+    //   1.0: { tickets: [<ticket>, ...] }            — array form
+    //   1.1: { tickets: { "1": <ticket>, ... } }     — object keyed by id
+    //   bare array: [<ticket>, ...]                  — legacy/test form
+    let tickets = [];
+    if (parsed && typeof parsed === 'object') {
+        const t = parsed.tickets;
+        if (Array.isArray(t))
+            tickets = t;
+        else if (t && typeof t === 'object')
+            tickets = Object.values(t);
+        else if (Array.isArray(parsed))
+            tickets = parsed;
+    }
+    if (tickets.length === 0)
+        return null;
+    const cap = exports.SPEC_CONCAT_TOKEN_CAP * exports.BYTES_PER_TOKEN;
+    const parts = [];
+    let total = 0;
+    let truncated = false;
+    for (const t of tickets) {
+        if (!t || typeof t !== 'object')
+            continue;
+        const x = t;
+        const id = typeof x.id === 'number' ? x.id : (typeof x.id === 'string' ? x.id : '?');
+        const title = typeof x.title === 'string' ? x.title : '(untitled)';
+        const status = typeof x.status === 'string' ? x.status : '?';
+        const priority = typeof x.priority === 'string' ? x.priority : '—';
+        const labels = Array.isArray(x.labels) ? x.labels.filter((l) => typeof l === 'string') : [];
+        const description = typeof x.description === 'string' ? x.description : '';
+        const labelLine = labels.length > 0 ? ` · labels: ${labels.join(', ')}` : '';
+        const block = `### #${id} · ${title}\nstatus: ${status} · priority: ${priority}${labelLine}\n\n${description}\n\n`;
+        const blockBytes = Buffer.byteLength(block);
+        if (total + blockBytes > cap) {
+            const remaining = Math.max(0, cap - total);
+            if (remaining > 0) {
+                parts.push(block.slice(0, remaining));
+                total = cap;
+            }
+            truncated = true;
+            break;
+        }
+        parts.push(block);
+        total += blockBytes;
+    }
+    if (parts.length === 0)
+        return null;
+    return `## Specrails Tickets\n\n${parts.join('')}${truncated ? '\n(truncated)\n' : ''}`;
+}
+function buildOpenSpecSpecsSection(projectPath) {
+    const root = node_path_1.default.join(projectPath, 'openspec', 'specs');
+    // Only include `spec.md` files under each capability directory.
+    const files = walkMdFiles(root, (rel) => rel.endsWith('spec.md'));
+    if (files.length === 0)
+        return null;
+    const cap = exports.SPEC_CONCAT_TOKEN_CAP * exports.BYTES_PER_TOKEN;
+    const { text, truncated } = concatFilesWithCap(files, cap);
+    if (!text)
+        return null;
+    return `## OpenSpec Specs\n\n${text}${truncated ? '\n(truncated)\n' : ''}`;
+}
+function buildScopedSystemPromptPrefix(scope, projectPath) {
+    const sections = [];
+    if (scope.specrails) {
+        const s = buildSpecrailsTicketsSection(projectPath);
+        if (s)
+            sections.push(s);
+    }
+    if (scope.openspec) {
+        const s = buildOpenSpecSpecsSection(projectPath);
+        if (s)
+            sections.push(s);
+    }
+    return sections.join('\n\n');
+}
+// Compute the claude CLI tool flags for the given scope.
+// We use `--tools` (whitelist) instead of `--disallowedTools` because
+// `--dangerously-skip-permissions` can bypass disallow filters in some CLI
+// versions; an explicit whitelist is the most reliable lockdown.
+//
+// - full=true   → --tools Read,Grep,Glob (Bash is NEVER auto-allowed)
+// - full=false  → --tools __none__ (a non-existent tool name; effectively
+//                 disables all tools because Commander.js requires a non-empty
+//                 value, and the empty string `""` is silently dropped by some
+//                 CLI versions, falling back to the default tool set).
+function toolFlagsForScope(scope) {
+    if (scope.full) {
+        return { args: ['--tools', 'Read,Grep,Glob'] };
+    }
+    return { args: ['--tools', '__none__'] };
+}