@specship/specship-win32-arm64 0.12.0 → 0.13.0

package/lib/dist/server/routes/claude.js

@@ -7,12 +7,14 @@
  *
  * Endpoints:
  *   GET /api/claude/projects                 — every indexed Claude project
- *   GET /api/claude/sessions?project=&limit= — sessions list
+ *   GET /api/claude/sessions?project=&limit=&range=&model= — sessions list
+ *   GET /api/claude/prompts/recent?project=&limit= — newest user prompts (⌘K palette)
  *   GET /api/claude/session/:id              — session detail (prompts + tools)
- *   GET /api/claude/heatmap?range=           — file/tool/subagent heatmaps
- *   GET /api/claude/costs?range=             — cost rollup, timeseries, per-model
+ *   GET /api/claude/heatmap?range=&project=  — file/tool/subagent heatmaps
+ *   GET /api/claude/costs?range=&project=&model= — cost rollup, timeseries, per-model
  *   GET /api/claude/compare                  — per-project cost comparison
- *   GET /api/claude/tips                     — rule-based tips engine output
+ *   GET /api/claude/tips                     — rule-based tips engine output (minus dismissed)
+ *   POST /api/claude/tips/state              — persist a tip's Apply/Dismiss state
  *   GET /api/claude/specship-impact?range=&project= — SpecShip token-impact aggregation
  *   POST /api/claude/ingest                  — force a one-shot ingest pass
  */
@@ -94,6 +96,7 @@ function getDb(cg) {
         return anyCg.queries.db;
     throw new Error('specship DB handle not accessible from server context');
 }
+// @implements REQ-DESKTOP-019 (GET /api/claude/prompts/recent — ⌘K palette prompts source)
 export async function registerClaudeRoutes(app) {
     /**
      * Analytics routes share one SQLite — the boot-time "primary" project's
@@ -135,20 +138,54 @@ export async function registerClaudeRoutes(app) {
         const limit = Math.min(parseInt(req.query.limit ?? '100', 10) || 100, 500);
         const since = rangeStart(rangeKey(req.query.range));
         const params = [since];
-        let whereProject = '';
+        let where = '';
         if (req.query.project) {
-            whereProject = ' AND project_path = ?';
+            where += ' AND project_path = ?';
             params.push(normalizeProjectFilter(req.query.project));
         }
+        if (req.query.model) {
+            where += ' AND last_model = ?';
+            params.push(req.query.model);
+        }
         params.push(limit);
         const sessions = db.prepare(`
       SELECT * FROM claude_sessions
-      WHERE started_at >= ?${whereProject}
+      WHERE started_at >= ?${where}
       ORDER BY started_at DESC
       LIMIT ?
     `).all(...params);
         return { sessions };
     });
+    /**
+     * Newest user prompts across sessions — feeds the ⌘K command palette's
+     * "recent prompts" results (REQ-DESKTOP-019). Main-chain prompts with
+     * non-empty text only: sidechain rows are subagent task bodies, and blank
+     * rows would render as empty palette entries. Text is capped at 200 chars —
+     * the palette shows a one-line label, never the full prompt.
+     */
+    app.get('/api/claude/prompts/recent', async (req, reply) => {
+        const cg = requirePrimary(reply);
+        if (!cg)
+            return;
+        const db = getDb(cg);
+        const limit = Math.min(parseInt(req.query.limit ?? '20', 10) || 20, 50);
+        const params = [];
+        let whereProject = '';
+        if (req.query.project) {
+            whereProject = ' AND s.project_path = ?';
+            params.push(normalizeProjectFilter(req.query.project));
+        }
+        params.push(limit);
+        const prompts = db.prepare(`
+      SELECT p.id, p.session_id, substr(p.text, 1, 200) as text, p.ts
+      FROM claude_prompts p
+      JOIN claude_sessions s ON s.id = p.session_id
+      WHERE p.is_sidechain = 0 AND p.text IS NOT NULL AND TRIM(p.text) != ''${whereProject}
+      ORDER BY p.ts DESC
+      LIMIT ?
+    `).all(...params);
+        return { prompts };
+    });
     app.get('/api/claude/session/:id', async (req, reply) => {
         const cg = requirePrimary(reply);
         if (!cg)
@@ -392,15 +429,20 @@ export async function registerClaudeRoutes(app) {
             return;
         const db = getDb(cg);
         const since = rangeStart(rangeKey(req.query.range));
+        // Optional project narrowing (REQ-DESKTOP-024.A2) — tool calls and prompts
+        // carry only session_id, so scope through claude_sessions.project_path.
+        const project = req.query.project ? normalizeProjectFilter(req.query.project) : undefined;
+        const inProject = (col = '') => project ? ` AND ${col}session_id IN (SELECT id FROM claude_sessions WHERE project_path = ?)` : '';
+        const withProject = (...lead) => (project ? [...lead, project] : lead);
         // Files heatmap — input_summary doubles as the file path for Read/Edit/Write.
         const files = db.prepare(`
       SELECT input_summary as path, COUNT(*) as calls, SUM(result_length) as resultBytes
       FROM claude_tool_calls
-      WHERE ts >= ? AND tool_name IN ('Read','Edit','Write','NotebookEdit') AND input_summary != ''
+      WHERE ts >= ? AND tool_name IN ('Read','Edit','Write','NotebookEdit') AND input_summary != ''${inProject()}
       GROUP BY input_summary
       ORDER BY calls DESC
       LIMIT 100
-    `).all(since);
+    `).all(...withProject(since));
         // Per-file 7-day call trend — one sparkline (oldest→newest) per file cell.
         // Always a fixed 7-day window, independent of `range`, so the trend reads
         // consistently regardless of the heatmap's selected window.
@@ -409,9 +451,9 @@ export async function registerClaudeRoutes(app) {
         const trendRows = db.prepare(`
       SELECT input_summary as path, CAST((ts - ?) / ? AS INTEGER) as bucket, COUNT(*) as calls
       FROM claude_tool_calls
-      WHERE ts >= ? AND tool_name IN ('Read','Edit','Write','NotebookEdit') AND input_summary != ''
+      WHERE ts >= ? AND tool_name IN ('Read','Edit','Write','NotebookEdit') AND input_summary != ''${inProject()}
       GROUP BY input_summary, bucket
-    `).all(trend7Start, dayMs, trend7Start);
+    `).all(...withProject(trend7Start, dayMs, trend7Start));
         const trendByPath = new Map();
         for (const r of trendRows) {
             if (r.bucket < 0 || r.bucket > 6)
@@ -427,10 +469,10 @@ export async function registerClaudeRoutes(app) {
         const tools = db.prepare(`
       SELECT tool_name as name, COUNT(*) as calls, SUM(result_length) as resultBytes
       FROM claude_tool_calls
-      WHERE ts >= ?
+      WHERE ts >= ?${inProject()}
       GROUP BY tool_name
       ORDER BY calls DESC
-    `).all(since);
+    `).all(...withProject(since));
         // Subagent attribution (is_sidechain at the prompt level — main vs. sidechain rollup).
         const subagents = db.prepare(`
       SELECT
@@ -439,9 +481,9 @@ export async function registerClaudeRoutes(app) {
         SUM(p.input_tokens + p.output_tokens + p.cache_creation_tokens + p.cache_read_tokens) as tokens,
         SUM(p.cost_usd) as cost
       FROM claude_prompts p
-      WHERE p.ts >= ?
+      WHERE p.ts >= ?${inProject('p.')}
       GROUP BY type
-    `).all(since);
+    `).all(...withProject(since));
         // Subagent breakdown by name — Task tool calls grouped by subagent_type
         // (defaults to 'general-purpose' when unset). Guarded extraction: Task
         // inputs carry long prompts, so input_summary is almost always truncated.
@@ -452,10 +494,10 @@ export async function registerClaudeRoutes(app) {
         MIN(ts) as firstSeen,
         MAX(ts) as lastSeen
       FROM claude_tool_calls
-      WHERE ts >= ? AND tool_name = 'Task'
+      WHERE ts >= ? AND tool_name = 'Task'${inProject()}
       GROUP BY name
       ORDER BY calls DESC
-    `).all(since);
+    `).all(...withProject(since));
         return { files, tools, subagents, subagentByName };
     });
     /**
@@ -627,40 +669,72 @@ export async function registerClaudeRoutes(app) {
             return;
         const db = getDb(cg);
         const since = rangeStart(rangeKey(req.query.range));
-        const total = db.prepare(`SELECT SUM(total_cost_usd) as t FROM claude_sessions WHERE started_at >= ?`).get(since);
+        // Optional narrowing (REQ-DESKTOP-024.A2). Both filters live at the prompt
+        // level (project via the owning session), so every prompt query below
+        // shares one fragment; the sessions join is only added when needed.
+        const project = req.query.project ? normalizeProjectFilter(req.query.project) : undefined;
+        const model = req.query.model || undefined;
+        const filtered = Boolean(project || model);
+        const pJoin = project ? ' JOIN claude_sessions s ON s.id = p.session_id' : '';
+        const pFilter = (project ? ' AND s.project_path = ?' : '') + (model ? ' AND p.model = ?' : '');
+        const pParams = (...lead) => {
+            const out = [...lead];
+            if (project)
+                out.push(project);
+            if (model)
+                out.push(model);
+            return out;
+        };
+        // Total spend in the window. Unfiltered keeps the session-level rollup
+        // (matches the dashboard's historical numbers, which include prompts with
+        // a NULL model); filtered totals must come from the same prompt rows the
+        // filters apply to, or the headline wouldn't narrow with the breakdowns.
+        const totalOf = (start, end) => {
+            if (!filtered) {
+                const where = end == null ? 'started_at >= ?' : 'started_at >= ? AND started_at < ?';
+                const row = db.prepare(`SELECT SUM(total_cost_usd) as t FROM claude_sessions WHERE ${where}`)
+                    .get(...(end == null ? [start] : [start, end]));
+                return row.t ?? 0;
+            }
+            const where = end == null ? 'p.ts >= ?' : 'p.ts >= ? AND p.ts < ?';
+            const row = db.prepare(`SELECT SUM(p.cost_usd) as t FROM claude_prompts p${pJoin} WHERE ${where}${pFilter}`)
+                .get(...pParams(...(end == null ? [start] : [start, end])));
+            return row.t ?? 0;
+        };
+        const total = totalOf(since, null);
         // Week-over-week spend delta: fractional change in total cost vs the prior
         // equal-length window (e.g. -0.08 → "-8%"). Zero for 'all' or no prior data.
         const prior = priorWindow(rangeKey(req.query.range));
         let wowDelta = 0;
         if (prior.end > prior.start) {
-            const pTotal = db.prepare(`SELECT SUM(total_cost_usd) as t FROM claude_sessions WHERE started_at >= ? AND started_at < ?`).get(prior.start, prior.end);
-            const pt = pTotal.t ?? 0;
+            const pt = totalOf(prior.start, prior.end);
             if (pt > 0)
-                wowDelta = ((total.t ?? 0) - pt) / pt;
+                wowDelta = (total - pt) / pt;
         }
-        // Top prompts by cost.
+        // Top prompts by cost. is_sidechain rides along so the dashboard's
+        // Recent-prompts module can badge subagent turns (REQ-DESKTOP-020).
         const topPrompts = db.prepare(`
-      SELECT id, session_id, substr(text, 1, 200) as text, model, cost_usd,
-             input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens, ts
-      FROM claude_prompts
-      WHERE ts >= ? AND cost_usd > 0
-      ORDER BY cost_usd DESC
+      SELECT p.id, p.session_id, substr(p.text, 1, 200) as text, p.model, p.cost_usd, p.is_sidechain,
+             p.input_tokens, p.output_tokens, p.cache_creation_tokens, p.cache_read_tokens, p.ts
+      FROM claude_prompts p${pJoin}
+      WHERE p.ts >= ? AND p.cost_usd > 0${pFilter}
+      ORDER BY p.cost_usd DESC
       LIMIT 50
-    `).all(since);
+    `).all(...pParams(since));
         // Daily timeseries: bucket by 24h windows.
         const days = 30;
         const dayMs = 24 * 60 * 60 * 1000;
         const dayBoundary = Math.floor(Date.now() / dayMs) * dayMs - (days - 1) * dayMs;
         const series = db.prepare(`
       SELECT
-        CAST((ts - ?) / ? AS INTEGER) as bucket,
-        SUM(cost_usd) as cost,
+        CAST((p.ts - ?) / ? AS INTEGER) as bucket,
+        SUM(p.cost_usd) as cost,
         COUNT(*) as prompts
-      FROM claude_prompts
-      WHERE ts >= ?
+      FROM claude_prompts p${pJoin}
+      WHERE p.ts >= ?${pFilter}
       GROUP BY bucket
       ORDER BY bucket ASC
-    `).all(dayBoundary, dayMs, dayBoundary);
+    `).all(...pParams(dayBoundary, dayMs, dayBoundary));
         // Densify with zeros for missing days.
         const dense = [];
         for (let i = 0; i < days; i++) {
@@ -669,13 +743,13 @@ export async function registerClaudeRoutes(app) {
         }
         // By model.
         const byModel = db.prepare(`
-      SELECT model, COUNT(*) as prompts, SUM(cost_usd) as cost
-      FROM claude_prompts
-      WHERE ts >= ? AND model IS NOT NULL
-      GROUP BY model
+      SELECT p.model, COUNT(*) as prompts, SUM(p.cost_usd) as cost
+      FROM claude_prompts p${pJoin}
+      WHERE p.ts >= ? AND p.model IS NOT NULL${pFilter}
+      GROUP BY p.model
       ORDER BY cost DESC
-    `).all(since);
-        return { total: total.t ?? 0, topPrompts, series: dense, byModel, wowDelta };
+    `).all(...pParams(since));
+        return { total, topPrompts, series: dense, byModel, wowDelta };
     });
     /**
      * GET /api/claude/stats?range= — the four dashboard stat tiles, each with a
@@ -742,7 +816,11 @@ export async function registerClaudeRoutes(app) {
         // --- Drift (live graph count, no time series) ---
         const driftCount = cg.getSpecQueries().getLinksByState(['drifted', 'broken', 'orphaned']).length;
         const drift = { value: driftCount, delta: 0, series: [] };
-        return { lastSessionCost, toolCalls, subagentPct, drift };
+        // Total ingested sessions (all time, unfiltered). Zero means "nothing
+        // ingested yet" — the dashboard renders enable-ingest guidance instead of
+        // presenting $0 / 0-call zeros as truth (REQ-DESKTOP-020.A4).
+        const sessionCount = countSince(`SELECT COUNT(*) c FROM claude_sessions`);
+        return { lastSessionCost, toolCalls, subagentPct, drift, sessionCount };
     });
     app.get('/api/claude/compare', async (_req, reply) => {
         const cg = requirePrimary(reply);
@@ -898,7 +976,40 @@ export async function registerClaudeRoutes(app) {
         // Sort: errors before warns before info, then within bucket by saving heuristic.
         const order = { error: 0, warn: 1, info: 2 };
         tips.sort((a, b) => (order[a.severity] ?? 9) - (order[b.severity] ?? 9));
-        return { tips };
+        // Apply persisted tip state (REQ-DESKTOP-020.A2): dismissed tips never
+        // resurface even though the rule re-mines the pattern; applied ones stay
+        // in the list annotated so the UI can render their applied treatment.
+        const states = db.prepare(`SELECT tip_id, state FROM claude_tip_state`).all();
+        const stateById = new Map(states.map((s) => [s.tip_id, s.state]));
+        const visible = tips.filter((t) => stateById.get(t.id) !== 'dismissed');
+        for (const t of visible) {
+            if (stateById.get(t.id) === 'applied')
+                t.state = 'applied';
+        }
+        return { tips: visible };
+    });
+    /**
+     * Persist a tip's Apply / Dismiss state (REQ-DESKTOP-020.A2). Tip ids embed
+     * `/` and `:` (rule + session + file), so the id travels in the JSON body
+     * rather than a path param. Upsert: re-applying or re-dismissing converges
+     * to one row per tip.
+     */
+    app.post('/api/claude/tips/state', async (req, reply) => {
+        const cg = requirePrimary(reply);
+        if (!cg)
+            return;
+        const { id, state } = req.body ?? {};
+        if (!id || typeof id !== 'string')
+            return reply.code(400).send({ error: 'id required' });
+        if (state !== 'applied' && state !== 'dismissed') {
+            return reply.code(400).send({ error: "state must be 'applied' or 'dismissed'" });
+        }
+        const db = getDb(cg);
+        db.prepare(`
+      INSERT INTO claude_tip_state (tip_id, state, ts) VALUES (?, ?, ?)
+      ON CONFLICT(tip_id) DO UPDATE SET state = excluded.state, ts = excluded.ts
+    `).run(id, state, Date.now());
+        return { ok: true, id, state };
     });
     /**
      * GET /api/claude/specship-impact?range=&project=
@@ -906,7 +1017,7 @@ export async function registerClaudeRoutes(app) {
      * Aggregate SpecShip token-impact metrics: how many tokens specship calls
      * spent vs. how many tokens' worth of Read calls they displaced (saved),
      * with per-prompt dedup so a file referenced by two specship calls in the
-     * same prompt counts only once. See packages/server/src/ingest/impact-query.ts
+     * same prompt counts only once. See server/src/ingest/impact-query.ts
      * for the full algorithm.
      *
      * Query params:

package/lib/dist/server/routes/config.js

@@ -0,0 +1,35 @@
+/**
+ * GET/PUT /api/config — the dashboard-visible server runtime configuration
+ * (REQ-DESKTOP-028.A2/.A3). Currently one knob: the Claude Code transcript
+ * ingest toggle, persisted to `~/.specship/server-config.json` so it
+ * survives restarts, plus the real product version for the About section.
+ *
+ * PUT flips the live watcher through `app.ingestControl` (server.ts): off
+ * stops the JSONL watcher immediately, on starts it (when a primary project
+ * with a DB handle exists — otherwise the intent is recorded and honored on
+ * the next boot with a primary).
+ */
+import { productVersion } from '../product-version.js';
+import { writeServerConfig } from '../server-config.js';
+export async function registerConfigRoutes(app) {
+    app.get('/api/config', async () => ({
+        ingestEnabled: app.ingestControl.enabled(),
+        version: productVersion(),
+    }));
+    app.put('/api/config', async (req, reply) => {
+        const body = (req.body ?? {});
+        if (typeof body.ingestEnabled !== 'boolean') {
+            return reply.code(400).send({ error: 'ingestEnabled must be a boolean', code: 'bad_request' });
+        }
+        writeServerConfig({ ingestEnabled: body.ingestEnabled });
+        if (body.ingestEnabled)
+            await app.ingestControl.start();
+        else
+            app.ingestControl.stop();
+        return {
+            ok: true,
+            ingestEnabled: app.ingestControl.enabled(),
+            version: productVersion(),
+        };
+    });
+}

package/lib/dist/server/routes/graph.js

@@ -160,6 +160,7 @@ export async function registerGraphRoutes(app) {
      *   - linkHealth: spec-link counts per state (verified/drifted/broken/orphaned/…)
      *   - edgeKinds:  edge counts grouped into calls / implements-documents / tests
      *   - hubs:       the most-connected nodes (by total degree), for the "Most connected" list
+     *   - anchored:   nodes that are spec_links targets (by degree), for the "Anchored" list
      */
     app.get('/api/graph/health', async (req, reply) => {
         const cg = await resolveCg(app, req, reply);
@@ -206,7 +207,27 @@ export async function registerGraphRoutes(app) {
       JOIN nodes n ON n.id = deg.node
       ORDER BY deg.degree DESC
     `).all();
-        return { linkHealth, edgeKinds: edgeKindMap, hubs };
+        // Anchored nodes — code that specs point at (resolved spec_links targets),
+        // most-connected first. Degree is LEFT-joined: an anchored leaf with no
+        // edges still shows up, at degree 0.
+        const anchored = db.prepare(`
+      SELECT n.id, n.name, n.kind, n.file_path as filePath, COALESCE(deg.degree, 0) as degree
+      FROM (
+        SELECT DISTINCT resolved_node_id AS node FROM spec_links
+        WHERE resolved_node_id IS NOT NULL
+      ) sl
+      JOIN nodes n ON n.id = sl.node
+      LEFT JOIN (
+        SELECT node, COUNT(*) as degree FROM (
+          SELECT source as node FROM edges
+          UNION ALL
+          SELECT target as node FROM edges
+        ) GROUP BY node
+      ) deg ON deg.node = n.id
+      ORDER BY degree DESC
+      LIMIT 8
+    `).all();
+        return { linkHealth, edgeKinds: edgeKindMap, hubs, anchored };
     });
     /**
      * Full-graph overview for the Graph page's whole-repo view. The graph can be