gipity 1.1.5 → 1.1.7

package/dist/commands/workflow.js

@@ -1,4 +1,4 @@
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { get, post, put, del } from '../api.js';
 import { getConfig, requireConfig } from '../config.js';
 import { success, error as clrError, muted, bold } from '../colors.js';
@@ -29,6 +29,51 @@ function formatRunLine(r) {
     const statusColor = r.status === 'completed' ? success : r.status === 'failed' ? clrError : muted;
     return `${muted(r.short_guid)}  ${statusColor(r.status)}  ${dur}  ${runTokens(r)} tokens  ${muted(fmtTime(r.started_at))}`;
 }
+/** Classify a step-output value that is a *string* holding JSON: parsed, or
+ *  looks-like-JSON-but-doesn't-parse (a truncated / cut-off llm response — the
+ *  step reports `completed` and the next step then can't read a field out of
+ *  it). `null` means "not a JSON string at all". */
+function jsonStringInfo(v) {
+    if (typeof v !== 'string')
+        return null;
+    const t = v.trim();
+    if (!t.startsWith('{') && !t.startsWith('['))
+        return null;
+    try {
+        const parsed = JSON.parse(t);
+        return typeof parsed === 'object' && parsed !== null ? { ok: true, value: parsed } : null;
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function labelFor(info) {
+    return info.ok ? '(JSON string)' : clrError('(truncated/invalid JSON string)');
+}
+/** Render one step's output for humans.
+ *
+ *  Step outputs routinely carry a JSON *string* under a key — an `llm` step's
+ *  `result` is the common case. Dumped through a plain JSON.stringify that
+ *  arrives as one enormous backslash-escaped line: unreadable, and it hides the
+ *  single fact you need most, that the NEXT step sees a string, not an object
+ *  (so `{{step.summary}}` resolves to nothing). Label such keys
+ *  `"key" (JSON string)` and print the decoded value indented under it, so both
+ *  the content and the string-vs-object handoff are obvious at a glance. */
+function renderStepOutput(output) {
+    if (output && typeof output === 'object' && !Array.isArray(output)) {
+        return Object.entries(output).map(([k, v]) => {
+            const info = jsonStringInfo(v);
+            if (!info)
+                return `${JSON.stringify(k)}: ${JSON.stringify(v, null, 2)}`;
+            const body = info.ok ? JSON.stringify(info.value, null, 2) : JSON.stringify(v);
+            return `${JSON.stringify(k)} ${labelFor(info)}: ${body}`;
+        }).join('\n');
+    }
+    const info = jsonStringInfo(output);
+    if (info?.ok)
+        return JSON.stringify(info.value, null, 2);
+    return JSON.stringify(output, null, 2);
+}
 /** Print each step's status, tokens, model, error and output. A run line alone
  *  says a run finished, not what it did — without the steps you can't tell a
  *  workflow that wrote a row from one that silently skipped every step. */
@@ -46,7 +91,7 @@ function printStepRuns(steps, emptyNote) {
         if (s.error_message)
             console.log(`     ${clrError(s.error_message)}`);
         if (s.output_json !== null && s.output_json !== undefined) {
-            console.log(JSON.stringify(s.output_json, null, 2).split('\n').map(l => `     ${l}`).join('\n'));
+            console.log(renderStepOutput(s.output_json).split('\n').map(l => `     ${l}`).join('\n'));
         }
     }
 }
@@ -149,10 +194,18 @@ workflowCommand
 }));
 workflowCommand
     .command('run <name>')
-    .description('Trigger a workflow (add --wait to block until it finishes)')
+    .description("Run a workflow: waits for it to finish and prints each step's status and output (--no-wait to fire and forget)")
     .option('--json', 'Output as JSON')
-    .option('--wait', 'Block until the triggered run reaches a terminal state, then print it')
-    .option('--timeout <s>', 'Max seconds to wait with --wait', '120')
+    // Waiting is the default: a bare trigger tells you nothing about what the
+    // workflow did, so every caller followed it with a poll-and-drill-in loop.
+    // `--no-wait` is the escape hatch for fire-and-forget.
+    .option('--no-wait', 'Trigger and return immediately instead of waiting for the run')
+    // Waiting is already the default, but `--wait` reads naturally and older
+    // docs/muscle memory reach for it — accept it silently rather than erroring.
+    .addOption(new Option('--wait', 'Wait for the run (already the default)').hideHelp())
+    // LLM steps routinely take a couple of minutes; a 120s default timed out on
+    // healthy runs and taught callers to always pass --timeout.
+    .option('--timeout <s>', 'Max seconds to wait for the run to finish', '300')
     .action((name, _opts, cmd) => run('Run', async () => {
     const opts = mergedOpts(cmd);
     const wf = await resolveWorkflow(name);
@@ -168,7 +221,7 @@ workflowCommand
     const before = await get(`/workflows/${wf.short_guid}/runs?limit=1`);
     const prevGuid = before.data[0]?.short_guid;
     await post(`/workflows/${wf.short_guid}/run`, {});
-    const r = await waitForRun(wf.short_guid, prevGuid, Number(opts.timeout) || 120);
+    const r = await waitForRun(wf.short_guid, prevGuid, Number(opts.timeout) || 300);
     if (opts.json) {
         console.log(JSON.stringify(r));
     }

package/dist/db-checkpoint.js

@@ -0,0 +1,42 @@
+/**
+ * Database checkpoint / restore — the undo for a LIVE write test.
+ *
+ * Verifying a write path for real (clicking Approve in the deployed UI, calling
+ * a function that inserts, letting a scheduled workflow run) mutates the
+ * project's real data, and there was no way to put it back - agents ended up
+ * hand-writing SQL to scrub their own test strings out.
+ *
+ * The snapshot itself is the SERVER's job: it lives in a sibling schema the app
+ * can't see, and restore runs in one transaction. This module is just the
+ * client - the CLI never composes checkpoint DDL, so a snapshot can never show
+ * up in `db query`, in a migration diff, or in app code that enumerates tables.
+ */
+import { get, post } from './api.js';
+/** First database in the project, or null when the project has none. */
+export async function resolveDatabase(projectGuid, explicit) {
+    if (explicit)
+        return explicit;
+    const res = await get(`/projects/${projectGuid}/databases`);
+    return res.data.length > 0 ? res.data[0].friendlyName : null;
+}
+async function checkpoint(projectGuid, database, action, keep) {
+    const res = await post(`/projects/${projectGuid}/db/checkpoint`, { database, action, ...(keep ? { keep } : {}) });
+    return res.data;
+}
+/** Snapshot every app table. Replaces any previous checkpoint. */
+export function createCheckpoint(projectGuid, database) {
+    return checkpoint(projectGuid, database, 'create');
+}
+/**
+ * Put every checkpointed table back to its snapshot contents and drop the
+ * snapshot (unless `keep`). Sequences are deliberately NOT rewound - leaving
+ * them ahead keeps ids unique against anything the test run handed out.
+ */
+export function restoreCheckpoint(projectGuid, database, opts = {}) {
+    return checkpoint(projectGuid, database, 'restore', opts.keep);
+}
+/** Drop the checkpoint without restoring (keep whatever the run wrote). */
+export function dropCheckpoint(projectGuid, database) {
+    return checkpoint(projectGuid, database, 'drop');
+}
+//# sourceMappingURL=db-checkpoint.js.map

package/dist/hooks/capture-runner.js

@@ -51,6 +51,7 @@ import { getConfig } from '../config.js';
 import { parseTranscript as parseClaudeTranscript, } from '../capture/sources/claude-code.js';
 import { parseTranscript as parseCodexTranscript } from '../capture/sources/codex.js';
 import { parseTranscript as parseGrokTranscript } from '../capture/sources/grok.js';
+import { parseTranscript as parseAgyTranscript } from '../capture/sources/agy.js';
 const CAPTURE_DIR = join(homedir(), '.gipity', 'capture-state');
 const INGEST_BATCH_MAX = 100; // server caps at 200; stay comfortably under
 export const CAPTURE_SOURCES = {
@@ -77,6 +78,14 @@ export const CAPTURE_SOURCES = {
             return join(homedir(), '.grok', 'sessions', encodeURIComponent(cwd), hook.session_id, 'chat_history.jsonl');
         },
     },
+    agy: {
+        serverSource: 'agy',
+        displayName: 'Antigravity',
+        // agy hook payloads always carry transcriptPath directly (no derivation
+        // needed, unlike Grok) - the agy-specific hook wrapper normalizes it into
+        // this HookInput's transcript_path before invoking this runner.
+        parse: (content, afterUuid, hook) => parseAgyTranscript(content, afterUuid, { conversationId: hook.session_id }),
+    },
 };
 // PostToolUse fires after every tool call. We flush on it so a session that is
 // killed/crashes mid-run (e.g. a long headless `gipity claude -p` build that
@@ -430,9 +439,10 @@ async function handleSessionEnd(convGuid, src, hook) {
     if (hook.session_id)
         deleteSessionMap(hook.session_id);
 }
-// Codex has no SessionEnd hook, so its capture-state/session-map files are
-// never cleaned by handleSessionEnd. Sweep anything stale on the way through
-// - the files are tiny, so a generous TTL is fine; a live session's state is
+// Codex and agy have no SessionEnd-equivalent hook, so their capture-state/
+// session-map files are never cleaned by handleSessionEnd. Sweep anything
+// stale on the way through - the files are tiny, so a generous TTL is fine; a
+// live session's state is
 // rewritten on every flush and never gets this old.
 const STATE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 function sweepStaleState() {
@@ -455,8 +465,10 @@ function sweepStaleState() {
 }
 /** Normalize a raw hook payload to snake_case HookInput. Claude Code and
  *  Codex deliver snake_case (`session_id`, `transcript_path`, `cwd`); Grok
- *  Build delivers camelCase (`sessionId`, `hookEventName`, …). Accept both
- *  so one runner serves every harness. */
+ *  Build delivers camelCase (`sessionId`, `hookEventName`, …); agy calls its
+ *  session id `conversationId` (its own hook payload has no session/cwd/event
+ *  fields under any other name - see cli/src/agents/agy.ts). Accept all of
+ *  these so one runner serves every harness. */
 export function normalizeHookInput(raw) {
     if (!raw || typeof raw !== 'object')
         return {};
@@ -469,7 +481,7 @@ export function normalizeHookInput(raw) {
         return undefined;
     };
     const hook = {
-        session_id: pick('session_id', 'sessionId'),
+        session_id: pick('session_id', 'sessionId', 'conversationId'),
         transcript_path: pick('transcript_path', 'transcriptPath'),
         cwd: pick('cwd', 'workingDirectory'),
         hook_event_name: pick('hook_event_name', 'hookEventName'),
@@ -509,8 +521,8 @@ async function main() {
         if (derived)
             hook.transcript_path = derived;
     }
-    // Opportunistic hygiene: Codex never fires session-end, so its state
-    // files are TTL-swept instead of deleted at end-of-session.
+    // Opportunistic hygiene: Codex and agy never fire session-end, so their
+    // state files are TTL-swept instead of deleted at end-of-session.
     sweepStaleState();
     const convGuid = await resolveConvGuid(hook, src.serverSource);
     if (!convGuid)