gipity 1.0.429 → 1.1.2

package/dist/capture/sources/grok.js

@@ -0,0 +1,178 @@
+/**
+ * Grok Build chat_history.jsonl transcript → ingest entries.
+ *
+ * Grok Build persists each session under
+ *   ~/.grok/sessions/<urlencoded-cwd>/<session_id>/
+ * with several files; `chat_history.jsonl` is the clean one-message-per-line
+ * conversation log and our parse target (events.jsonl is lifecycle noise,
+ * updates.jsonl is a chunked ACP stream). Verified against real sessions
+ * (Grok Build / grok-4.5, 2026-07-13). Line shapes:
+ *
+ *   { type: 'system',      content }                          → SKIP (system prompt)
+ *   { type: 'user',        content, synthetic_reason?, prompt_index? }
+ *       synthetic_reason present → SKIP (injected context, not the user)
+ *       else → prompt entry
+ *   { type: 'assistant',   content, tool_calls?: [{id,name,arguments}],
+ *                          model_id?, reasoning_effort? }     → assistant (+ tool_use per call)
+ *   { type: 'tool_result', tool_call_id, content }            → tool_result
+ *   { type: 'reasoning',   encrypted_content, summary }       → SKIP (parity with Claude parser)
+ *
+ * Grok hook payloads may not carry a transcript path; the capture runner
+ * derives it from the hook's cwd + session_id
+ * (`~/.grok/sessions/<encodeURIComponent(cwd)>/<session_id>/chat_history.jsonl`).
+ *
+ * Dedup/watermark: chat_history lines carry no uuid or timestamp, so uuids
+ * are synthesized. tool_use/tool_result key off the stable `tool_calls[].id`
+ * (`call-<uuid>-N`), which survives file rewrites; assistant/prompt entries
+ * use positional `<session_id>#<lineIndex>` uuids. The watermark is
+ * positional; a foreign watermark (session id mismatch / rotated file) makes
+ * the caller replay from the top, and the server's source_uuid unique index
+ * collapses anything already forwarded.
+ */
+function positional(sessionId, idx) {
+    return `${sessionId}#${idx}`;
+}
+function watermarkIndex(afterUuid, sessionId) {
+    if (!afterUuid || !sessionId)
+        return null;
+    const prefix = `${sessionId}#`;
+    if (!afterUuid.startsWith(prefix))
+        return null;
+    const idx = parseInt(afterUuid.slice(prefix.length), 10);
+    return Number.isInteger(idx) && idx >= 0 ? idx : null;
+}
+function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        // Defensive: some harness versions may block-structure content.
+        const parts = [];
+        for (const b of content) {
+            if (b && typeof b.text === 'string')
+                parts.push(b.text);
+        }
+        return parts.join('\n');
+    }
+    return '';
+}
+function lineToEntries(parsed, sessionId, idx, toolNames) {
+    if (!parsed || typeof parsed !== 'object' || typeof parsed.type !== 'string')
+        return [];
+    if (parsed.type === 'user') {
+        if (parsed.synthetic_reason)
+            return []; // injected context, not the user
+        let prompt = contentToText(parsed.content);
+        if (!prompt)
+            return [];
+        // Grok also injects an environment block as a PLAIN user line (no
+        // synthetic_reason) at session start - recognizable by its wrapper tag.
+        if (prompt.startsWith('<user_info>'))
+            return [];
+        // The real prompt arrives wrapped in <user_query> tags - unwrap for
+        // clean display; the wrapper is Grok plumbing, not what the user typed.
+        const m = prompt.match(/^<user_query>\s*([\s\S]*?)\s*<\/user_query>$/);
+        if (m)
+            prompt = m[1];
+        if (!prompt)
+            return [];
+        return [{ kind: 'prompt', prompt, source_uuid: positional(sessionId, idx) }];
+    }
+    if (parsed.type === 'assistant') {
+        const text = contentToText(parsed.content);
+        const out = [];
+        const calls = Array.isArray(parsed.tool_calls) ? parsed.tool_calls : [];
+        if (text || calls.length) {
+            out.push({
+                kind: 'assistant',
+                text,
+                blocks: text ? [{ type: 'text', text }] : [],
+                ...(typeof parsed.model_id === 'string' ? { model: parsed.model_id } : {}),
+                source_uuid: positional(sessionId, idx),
+            });
+        }
+        for (const call of calls) {
+            if (!call || typeof call.id !== 'string' || !call.id)
+                continue;
+            const toolName = typeof call.name === 'string' && call.name ? call.name : 'tool';
+            toolNames.set(call.id, toolName);
+            let toolInput = call.arguments ?? null;
+            if (typeof toolInput === 'string') {
+                try {
+                    toolInput = JSON.parse(toolInput);
+                }
+                catch { /* keep raw string */ }
+            }
+            out.push({
+                kind: 'tool_use',
+                tool_use_id: call.id,
+                tool_name: toolName,
+                tool_input: toolInput,
+                source_uuid: call.id,
+            });
+        }
+        return out;
+    }
+    if (parsed.type === 'tool_result') {
+        if (typeof parsed.tool_call_id !== 'string' || !parsed.tool_call_id)
+            return [];
+        return [{
+                kind: 'tool_result',
+                tool_use_id: parsed.tool_call_id,
+                tool_name: toolNames.get(parsed.tool_call_id),
+                content: parsed.content ?? null,
+                source_uuid: `${parsed.tool_call_id}#out`,
+            }];
+    }
+    return []; // system, reasoning, unknown
+}
+/** Parse the full chat_history JSONL and emit every ingest entry that comes
+ *  *after* the positional watermark `afterUuid`. Same contract as the
+ *  claude-code parser. */
+export function parseTranscript(content, afterUuid, ctx = {}) {
+    const sessionId = ctx.sessionId ?? '';
+    const lines = content.split('\n');
+    // A watermark pointing past EOF means the file shrank under the same
+    // session id (e.g. a rewind rewrote chat_history). Treat it as not-found
+    // so the caller replays from the top - otherwise capture wedges silently.
+    let startAfter = watermarkIndex(afterUuid, sessionId);
+    if (startAfter !== null && startAfter >= lines.length)
+        startAfter = null;
+    const foundWatermark = afterUuid === null || startAfter !== null;
+    const out = [];
+    const toolNames = new Map();
+    let lastIdx = startAfter;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (startAfter !== null && i <= startAfter) {
+            // Pre-watermark: record tool names only, so a post-watermark
+            // tool_result still resolves the name of an already-forwarded call.
+            if (parsed?.type === 'assistant' && Array.isArray(parsed.tool_calls)) {
+                for (const call of parsed.tool_calls) {
+                    if (call && typeof call.id === 'string' && call.id) {
+                        toolNames.set(call.id, typeof call.name === 'string' && call.name ? call.name : 'tool');
+                    }
+                }
+            }
+            continue;
+        }
+        const entries = lineToEntries(parsed, sessionId, i, toolNames);
+        for (const e of entries)
+            out.push(e);
+        lastIdx = i;
+    }
+    return {
+        entries: out,
+        lastUuid: lastIdx === null ? afterUuid : positional(sessionId, lastIdx),
+        foundWatermark,
+    };
+}
+//# sourceMappingURL=grok.js.map

package/dist/catalog.js

@@ -0,0 +1,46 @@
+/**
+ * The `gipity add` catalog - template + kit keys with terse list hints.
+ *
+ * AUTO-GENERATED - do not edit directly.
+ * Source: platform/packages/shared/src/constants.ts (TEMPLATES/KITS cliHint fields)
+ * Run `just build-knowledge` to refresh.
+ */
+/** Visible starter templates (complete working demos). */
+export const STARTERS = [
+    { key: 'web-vision-cam', hint: 'fullscreen camera app with on-device vision (MediaPipe)' },
+    { key: 'object-spotter', hint: 'camera app that boxes, labels, and counts objects (YOLOX on-device)' },
+    { key: '2d-game', hint: '2D games with Phaser 3 - platformer, arcade, puzzle' },
+    { key: '3d-world', hint: 'playable 3D multiplayer rocket-launcher demo' },
+    { key: 'karaoke-captions', hint: 'audio + lyrics -> word-synced karaoke captions (GPU job)' },
+    { key: 'outreach-agent', hint: 'AI-run outreach funnel - import contacts, draft + auto-send staged emails' },
+    { key: 'paid-app', hint: 'storefront that charges real money - Stripe checkout, members area, billing' },
+    { key: 'notify-demo', hint: 'web-push demo - enable notifications, send a real ping' },
+];
+/** Visible blank-wiring templates. */
+export const BLANK = [
+    { key: 'web-simple', hint: 'static frontend-only site - pages, dashboards, simple games' },
+    { key: 'web-fullstack', hint: 'backend API + database wiring - frontend, functions, migrations; deploys green' },
+    { key: '3d-engine', hint: '3D multiplayer wiring - Three.js + Rapier + Gipity Realtime' },
+    { key: 'api', hint: 'pure API backend, no frontend - one example function + test' },
+];
+/** Hidden templates - installable by exact key, omitted from listings. */
+export const HIDDEN = [
+    { key: 'app-itsm', hint: 'IT service management / helpdesk / ticketing' },
+    { key: 'monitor', hint: 'account observability dashboard (auto-installed per account)' },
+];
+/** Kits - building blocks added into an existing app. */
+export const KITS = [
+    { key: 'realtime', hint: 'multiplayer / presence / shared state' },
+    { key: 'web-vision-mediapipe', hint: 'browser camera vision - gesture, pose, object detection' },
+    { key: 'web-vision-detect', hint: 'browser object detection - YOLOX, WebGPU/WASM, custom models' },
+    { key: 'chatbot', hint: 'drop-in chatbot - persona, guardrails, streaming responses' },
+    { key: 'audio-align', hint: 'audio + lyrics -> word-level timing JSON (GPU job)' },
+    { key: 'i18n', hint: 'multi-language web apps - language picker, RTL, translations' },
+    { key: 'records', hint: 'registry-driven data plane - generic CRUD, validation, search, audit spine' },
+    { key: 'views', hint: 'registry-driven UI over records - table, forms, kanban' },
+    { key: 'agent-api', hint: 'named API keys for agent/script writes through the records kit' },
+    { key: 'contacts', hint: 'multi-source contact layer - LinkedIn/Gmail import, dedupe with provenance' },
+    { key: 'stripe', hint: 'charge your users - Stripe checkout, subscriptions, brokered webhooks' },
+    { key: 'notify', hint: 'web push notifications - platform-owned keys, works on iOS home screen' },
+];
+//# sourceMappingURL=catalog.js.map

package/dist/client-context.js

@@ -27,6 +27,8 @@ export function detectHarness() {
     }
     if (hasEnvPrefix('CODEX_'))
         return { harness: 'codex' };
+    if (hasEnvPrefix('GROK_'))
+        return { harness: 'grok', harnessSession: process.env.GROK_SESSION_ID };
     if (process.env.CURSOR_TRACE_ID || hasEnvPrefix('CURSOR_') || (process.env.TERM_PROGRAM ?? '').toLowerCase().includes('cursor')) {
         return { harness: 'cursor' };
     }

package/dist/commands/add.js

@@ -8,28 +8,15 @@ import { sync } from '../sync.js';
 import { success, muted, bold, warning, error as clrError } from '../colors.js';
 import { run } from '../helpers/index.js';
 import { createProgressReporter, withSpinner } from '../progress.js';
-const STARTERS = [
-    { key: 'web-vision-cam', hint: 'fullscreen camera app with on-device vision (MediaPipe)' },
-    { key: 'object-spotter', hint: 'camera app that boxes, labels, and counts objects (YOLOX on-device)' },
-    { key: '2d-game', hint: '2D games with Phaser 3 - platformer, arcade, puzzle' },
-    { key: '3d-world', hint: 'playable 3D multiplayer rocket-launcher demo' },
-    { key: 'karaoke-captions', hint: 'audio + lyrics -> word-synced karaoke captions (GPU job)' },
-];
-const BLANK = [
-    { key: 'web-simple', hint: 'static frontend-only site - pages, dashboards, simple games' },
-    { key: 'web-fullstack', hint: 'backend API + database wiring - frontend, functions, migrations; deploys green' },
-    { key: 'api', hint: 'pure API backend, no frontend - one example function + test' },
-    { key: '3d-engine', hint: '3D multiplayer wiring - Three.js + Rapier + Gipity Realtime' },
-];
-const HIDDEN = [{ key: 'app-itsm', hint: 'IT service management / helpdesk / ticketing' }];
-const KITS = [
-    { key: 'realtime', hint: 'multiplayer / presence / shared state' },
-    { key: 'web-vision-mediapipe', hint: 'browser camera vision - gesture, pose, object detection' },
-    { key: 'web-vision-detect', hint: 'browser object detection - YOLOX, WebGPU/WASM, custom models' },
-    { key: 'chatbot', hint: 'drop-in chatbot - persona, guardrails, streaming responses' },
-    { key: 'audio-align', hint: 'audio + lyrics -> word-level timing JSON (GPU job)' },
-    { key: 'i18n', hint: 'multi-language web apps - language picker, RTL, translations' },
-];
+// Catalog GENERATED from platform/packages/shared (TEMPLATES + KITS cliHint
+// fields) into src/catalog.ts by platform/scripts/build-knowledge.ts - the CLI
+// ships as a standalone npm package and can't depend on the private shared
+// workspace. The hand-mirrored copy that used to live here silently dropped
+// every new catalog entry; edit constants.ts + `just build-knowledge` instead.
+//
+// Templates install a whole app (blank wiring or a working starter demo).
+// Kits are reusable building blocks added into an existing app's src/packages/.
+import { STARTERS, BLANK, KITS } from '../catalog.js';
 // The catalog block, rendered once and reused by the full help output
 // (`gipity add` / `gipity add --help`) and the bare listing (`gipity add
 // --list`) so they can never drift. Three sections, one entry per line, keys