specrails-desktop 2.32.0 → 2.34.0

package/server/dist/repo-map.js

@@ -0,0 +1,293 @@
+"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.buildRepoMap = buildRepoMap;
+exports.formatRepoMap = formatRepoMap;
+exports.isRepoMapEnabled = isRepoMapEnabled;
+exports.ensureRepoMapFile = ensureRepoMapFile;
+exports.injectRepoMapEnv = injectRepoMapEnv;
+exports._clearRepoMapCache = _clearRepoMapCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const artifact_registry_1 = require("./artifact-registry");
+const SKIP_DIRS = new Set([
+    'node_modules', 'vendor', 'dist', 'build', 'out', 'coverage', 'target',
+    '__pycache__', 'venv', '.venv', 'Pods', 'DerivedData',
+]);
+/** Manifest filename → ecosystem label. First match wins (iteration order). */
+const MANIFESTS = [
+    ['package.json', 'node'],
+    ['pyproject.toml', 'python'],
+    ['setup.py', 'python'],
+    ['requirements.txt', 'python'],
+    ['go.mod', 'go'],
+    ['Cargo.toml', 'rust'],
+    ['pom.xml', 'jvm'],
+    ['build.gradle', 'jvm'],
+    ['build.gradle.kts', 'jvm'],
+    ['Package.swift', 'swift'],
+    ['Gemfile', 'ruby'],
+    ['composer.json', 'php'],
+];
+const MAX_SERVICES = 40;
+const README_MAX_LINES = 12;
+const README_MAX_CHARS = 800;
+/** File-count scan caps — the bucket is a rough size label, not a census. */
+const SCAN_MAX_DEPTH = 2;
+const SCAN_MAX_ENTRIES = 500;
+function buildRepoMap(repoDir) {
+    const services = [];
+    const seen = new Set();
+    const addService = (relDir) => {
+        if (seen.has(relDir) || services.length >= MAX_SERVICES + 1)
+            return;
+        const abs = relDir === '' ? repoDir : path.join(repoDir, relDir);
+        const eco = detectEcosystem(abs);
+        if (!eco)
+            return;
+        seen.add(relDir);
+        services.push({
+            dir: relDir,
+            name: packageName(abs) ?? (relDir === '' ? path.basename(repoDir) : path.basename(relDir)),
+            ecosystem: eco,
+            sizeBucket: sizeBucket(abs),
+            hasReadme: readmePath(abs) !== null,
+        });
+    };
+    addService('');
+    for (const entry of listDirs(repoDir)) {
+        addService(entry);
+    }
+    // npm/yarn workspaces can nest packages one level below the top-level scan.
+    for (const rel of resolveNpmWorkspaces(repoDir)) {
+        addService(rel);
+    }
+    const truncated = services.length > MAX_SERVICES;
+    return {
+        readmeExcerpt: readReadmeExcerpt(repoDir),
+        services: services.slice(0, MAX_SERVICES),
+        truncated,
+    };
+}
+function formatRepoMap(map) {
+    const lines = ['# Repository map (deterministic — generated by Specrails, no AI)', ''];
+    if (map.readmeExcerpt) {
+        lines.push('## README excerpt', '', map.readmeExcerpt, '');
+    }
+    lines.push('## Packages');
+    if (map.services.length === 0) {
+        lines.push('- (no recognized package manifests found)');
+    }
+    for (const s of map.services) {
+        const dirLabel = s.dir === '' ? './' : `${s.dir}/`;
+        const readme = s.hasReadme ? 'has README' : 'no README';
+        lines.push(`- \`${dirLabel}\` — ${s.name} (${s.ecosystem}, ${s.sizeBucket}, ${readme})`);
+    }
+    if (map.truncated) {
+        lines.push(`- … more packages omitted (cap ${MAX_SERVICES})`);
+    }
+    lines.push('', 'Use this map to orient exploration without spending turns on top-level discovery.', '');
+    return lines.join('\n');
+}
+const cache = new Map();
+const CACHE_TTL_MS = 60_000;
+function isRepoMapEnabled() {
+    return process.env.SPECRAILS_REPO_MAP !== 'false';
+}
+/**
+ * Build (or reuse, 60s TTL) the on-disk map for a repo/worktree. Returns the
+ * file path, or null on any failure — the map is an accelerator, never a
+ * spawn blocker.
+ */
+function ensureRepoMapFile(repoDir) {
+    try {
+        const real = fs.realpathSync(repoDir);
+        const hit = cache.get(real);
+        if (hit && Date.now() - hit.at < CACHE_TTL_MS && fs.existsSync(hit.filePath)) {
+            return hit.filePath;
+        }
+        const content = formatRepoMap(buildRepoMap(real));
+        const dir = path.join((0, artifact_registry_1.resolveHome)(), '.specrails', 'repo-maps');
+        fs.mkdirSync(dir, { recursive: true });
+        const filePath = path.join(dir, `${sha1(real)}.md`);
+        const tmp = `${filePath}.tmp-${process.pid}`;
+        fs.writeFileSync(tmp, content, 'utf8');
+        fs.renameSync(tmp, filePath);
+        cache.set(real, { filePath, at: Date.now() });
+        return filePath;
+    }
+    catch {
+        return null;
+    }
+}
+/** Add `SPECRAILS_REPO_MAP_PATH` to a spawn env. Never throws, never blocks. */
+function injectRepoMapEnv(env, repoDir) {
+    if (!repoDir || !isRepoMapEnabled())
+        return env;
+    const filePath = ensureRepoMapFile(repoDir);
+    return filePath ? { ...env, SPECRAILS_REPO_MAP_PATH: filePath } : env;
+}
+/** Test hook — clears the TTL cache. */
+function _clearRepoMapCache() {
+    cache.clear();
+}
+// ─── Internals ────────────────────────────────────────────────────────────────
+function sha1(value) {
+    return crypto.createHash('sha1').update(value).digest('hex');
+}
+function listDirs(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isDirectory() && !e.name.startsWith('.') && !SKIP_DIRS.has(e.name))
+        .map((e) => e.name)
+        .sort();
+}
+function detectEcosystem(dir) {
+    for (const [manifest, eco] of MANIFESTS) {
+        if (fs.existsSync(path.join(dir, manifest)))
+            return eco;
+    }
+    return null;
+}
+function packageName(dir) {
+    try {
+        const raw = fs.readFileSync(path.join(dir, 'package.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readmePath(dir) {
+    for (const name of ['README.md', 'readme.md', 'README.txt', 'README']) {
+        const p = path.join(dir, name);
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+function readReadmeExcerpt(repoDir) {
+    const p = readmePath(repoDir);
+    if (!p)
+        return null;
+    try {
+        const lines = fs.readFileSync(p, 'utf8').split('\n').slice(0, README_MAX_LINES);
+        const text = lines.join('\n').trim();
+        if (!text)
+            return null;
+        return text.length > README_MAX_CHARS ? `${text.slice(0, README_MAX_CHARS)}…` : text;
+    }
+    catch {
+        return null;
+    }
+}
+/** Rough size label from a capped, shallow file count. */
+function sizeBucket(dir) {
+    let count = 0;
+    const walk = (d, depth) => {
+        if (depth > SCAN_MAX_DEPTH || count > SCAN_MAX_ENTRIES)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (count > SCAN_MAX_ENTRIES)
+                return;
+            if (e.name.startsWith('.') || SKIP_DIRS.has(e.name))
+                continue;
+            if (e.isDirectory()) {
+                walk(path.join(d, e.name), depth + 1);
+            }
+            else {
+                count++;
+            }
+        }
+    };
+    walk(dir, 0);
+    if (count < 20)
+        return 'small';
+    if (count < 150)
+        return 'medium';
+    return 'large';
+}
+/**
+ * Resolve npm/yarn `workspaces` from the root package.json. Literal paths and
+ * trailing `/*` globs only — deliberately no glob library; anything fancier
+ * falls back to the top-level scan.
+ */
+function resolveNpmWorkspaces(repoDir) {
+    let patterns = [];
+    try {
+        const raw = fs.readFileSync(path.join(repoDir, 'package.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        const ws = parsed.workspaces;
+        if (Array.isArray(ws)) {
+            patterns = ws.filter((w) => typeof w === 'string');
+        }
+        else if (ws && typeof ws === 'object' && Array.isArray(ws.packages)) {
+            patterns = (ws.packages).filter((w) => typeof w === 'string');
+        }
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const pattern of patterns) {
+        const clean = pattern.replace(/^\.\//, '');
+        if (clean.endsWith('/*')) {
+            const base = clean.slice(0, -2);
+            const abs = path.join(repoDir, base);
+            for (const child of listDirs(abs)) {
+                out.push(path.join(base, child));
+            }
+        }
+        else if (!clean.includes('*')) {
+            out.push(clean);
+        }
+    }
+    return out;
+}

package/server/dist/setup-manager.js

@@ -732,6 +732,63 @@ class SetupManager {
         this._projectTiers = new Map();
         this._projectNames = new Map();
     }
+    // ─── Silent assemble (global-core-zero-friction) ─────────────────────────────
+    // Per-project silent-assemble state: running guard + failed providers for the
+    // retry affordance. Assembly failure NEVER rolls back registration.
+    _silentAssembles = new Map();
+    silentAssembleState(projectId) {
+        return this._silentAssembles.get(projectId) ?? { running: false, failed: [] };
+    }
+    /**
+     * Wizard-less background workspace assembly: one offline `init` per provider,
+     * sequential, per-provider failure isolation. Progress rides the app-level
+     * `project.assemble_progress` WS event ({projectId, provider, status}); the
+     * only client surface is the project card's subtle indicator. Idempotent per
+     * project (a second call while running is a no-op; a later call retries only
+     * failed/missing providers via core's own skip-when-populated behaviour).
+     */
+    startSilentAssemble(projectId, projectPath, slug, providers, opts) {
+        const state = this.silentAssembleState(projectId);
+        if (state.running)
+            return;
+        const list = (opts?.providersFilter ?? providers).filter((p) => (0, providers_1.hasAdapter)(p));
+        if (list.length === 0)
+            return;
+        this._silentAssembles.set(projectId, { running: true, failed: [] });
+        const emit = (provider, status, error) => {
+            this._broadcast({
+                type: 'project.assemble_progress',
+                projectId,
+                provider,
+                status,
+                ...(error ? { error } : {}),
+            });
+        };
+        void (0, offline_assemble_1.assembleProjectOffline)({
+            projectPath,
+            slug,
+            desktopProjectId: projectId,
+            providers: list,
+            continueOnError: true,
+            onProviderStart: (p) => emit(p, 'running'),
+            onProviderResult: (r) => emit(r.provider, r.ok ? 'done' : 'failed', r.error),
+        })
+            .then((results) => {
+            const failed = results.filter((r) => !r.ok).map((r) => r.provider);
+            this._silentAssembles.set(projectId, { running: false, failed });
+            if (failed.length > 0) {
+                console.warn(`[SetupManager] silent assemble: failed providers for ${projectId}: ${failed.join(', ')}`);
+            }
+        })
+            .catch((err) => {
+            // Workspace-missing or other terminal failure: mark every provider
+            // failed so the retry affordance covers the whole set.
+            this._silentAssembles.set(projectId, { running: false, failed: list });
+            console.error(`[SetupManager] silent assemble failed for ${projectId}:`, err);
+            for (const p of list)
+                emit(p, 'failed', err instanceof Error ? err.message : String(err));
+        });
+    }
     // ─── Full Install: TUI installer (npx specrails-core) ────────────────────────
     /**
      * Install ALL of the given providers in one shot: installs the first, then

package/server/dist/spending.js

@@ -4,6 +4,7 @@ exports.getSpending = getSpending;
 exports.summariseExplorePrompt = summariseExplorePrompt;
 exports.getInvocations = getInvocations;
 exports.parseSpendingFilters = parseSpendingFilters;
+exports.getAgentMissionSpending = getAgentMissionSpending;
 // The surfaces enumerated in the bySurface breakdown. Keep the original seven
 // analytics surfaces first (stable ordering / column layout), then the
 // cost-accounting-audit additions so a newly-recorded billable surface is
@@ -731,3 +732,47 @@ function parseSpendingFilters(query) {
     }
     return f;
 }
+function getAgentMissionSpending(desktopDb, projectId, filters) {
+    const range = resolveRange(filters);
+    const summaryRow = desktopDb.prepare(`
+    SELECT
+      COALESCE(SUM(total_cost_usd), 0) AS total,
+      COALESCE(SUM(CASE WHEN total_cost_usd_estimated = 1 THEN total_cost_usd ELSE 0 END), 0) AS estimated,
+      COUNT(*) AS turns,
+      COALESCE(SUM(tokens_in), 0) AS tokensIn,
+      COALESCE(SUM(tokens_out), 0) AS tokensOut
+    FROM agent_invocations
+    WHERE project_id = ? AND started_at >= ? AND started_at <= ?
+  `).get(projectId, range.from, range.to);
+    const prevRow = desktopDb.prepare(`
+    SELECT COALESCE(SUM(total_cost_usd), 0) AS total
+    FROM agent_invocations
+    WHERE project_id = ? AND started_at >= ? AND started_at < ?
+  `).get(projectId, range.prevFrom, range.prevTo);
+    const topConversations = (desktopDb.prepare(`
+    SELECT
+      ai.conversation_id AS conversationId,
+      ac.title AS title,
+      COALESCE(SUM(ai.total_cost_usd), 0) AS costUsd,
+      COALESCE(SUM(CASE WHEN ai.total_cost_usd_estimated = 1 THEN ai.total_cost_usd ELSE 0 END), 0) AS estimatedCostUsd,
+      COUNT(*) AS turns,
+      MAX(ai.started_at) AS lastAt
+    FROM agent_invocations ai
+    LEFT JOIN agent_conversations ac ON ac.id = ai.conversation_id
+    WHERE ai.project_id = ? AND ai.started_at >= ? AND ai.started_at <= ?
+    GROUP BY ai.conversation_id
+    ORDER BY costUsd DESC
+    LIMIT 5
+  `).all(projectId, range.from, range.to));
+    return {
+        summary: {
+            totalCostUsd: summaryRow.total,
+            estimatedCostUsd: summaryRow.estimated,
+            prevTotalCostUsd: prevRow.total,
+            turns: summaryRow.turns,
+            tokensIn: summaryRow.tokensIn,
+            tokensOut: summaryRow.tokensOut,
+        },
+        topConversations,
+    };
+}