gipity 1.0.422 → 1.0.425

package/dist/commands/sandbox.js

@@ -35,19 +35,57 @@ const PIN_LANGUAGE_HELP = [
     '  gipity sandbox run --language bash "<code>" # explicit flag (js | py | bash)',
     '  gipity sandbox run --file script.sh         # inferred from the file extension',
 ].join('\n');
+// Words that open a code statement, not a command line. A single positional
+// starting with one of these is a JS/Python snippet whose language we must not
+// guess (see resolveLanguage) - everything here is either invalid in bash or,
+// worse, VALID in bash with a different meaning (`export FOO=1`, `for ...`).
+const CODE_OPENERS = new Set([
+    'const', 'let', 'var', 'function', 'async', 'await', 'import', 'export',
+    'console', 'require', 'print', 'def', 'class', 'lambda', 'from', 'return',
+    'for', 'while', 'if', 'try', 'with',
+]);
+/**
+ * True when a bare inline string is unmistakably a shell COMMAND LINE
+ * (`node tests/game.test.js`, `ls -la`, `ffmpeg -i in.mp4 out.gif`) rather
+ * than a code snippet. Deliberately conservative: one line, starts with a
+ * plain command word (no parens/quotes/operators in it), not a code opener,
+ * not an assignment (`x = 1` is Python-or-bash-ambiguous). Anything that
+ * fails these checks still goes through the explicit-pin error below.
+ */
+export function looksLikeShellCommand(code) {
+    if (code.includes('\n'))
+        return false;
+    const m = /^([A-Za-z0-9_.~/-]+)(\s|$)/.exec(code.trim());
+    if (!m)
+        return false;
+    const token = m[1].toLowerCase();
+    if (CODE_OPENERS.has(token))
+        return false;
+    if (/^\s*[A-Za-z_][A-Za-z0-9_]*\s*=/.test(code))
+        return false; // assignment
+    // A lone bare word (`foo`) is as likely a typo as a command; require either
+    // arguments after the word or a path-shaped word (`./build.sh`, `bin/run`).
+    return /\s\S/.test(code.trim()) || token.includes('/');
+}
 /**
  * Resolve the language from an explicit signal, or exit.
  *
- * Precedence: interpreter token > --language > --file extension.
+ * Precedence: interpreter token > --language > --file extension > the
+ * command-line heuristic above (bash).
  *
- * There is no default. js/python/bash are mutually exclusive, and plenty of
- * snippets parse as more than one of them (`x = 1`, `a[0]`, `foo()`), so any
- * default silently runs some fraction of input in the wrong interpreter. The old
- * behavior defaulted to JavaScript, which meant a shell one-liner ran as JS and
- * died with a Node `SyntaxError` at `/work/_run.js` - after paying for a project
- * sync and a server round trip. Failing here instead costs nothing and says what
- * to type. (`docs/skills/sandbox-tools.md` used to carry a hand-written "always
- * pin the language" warning to work around this; the CLI enforces it now.)
+ * Beyond that there is no default. js/python/bash are mutually exclusive, and
+ * plenty of snippets parse as more than one of them (`x = 1`, `a[0]`, `foo()`),
+ * so a blanket default silently runs some fraction of input in the wrong
+ * interpreter. The old behavior defaulted to JavaScript, which meant a shell
+ * one-liner ran as JS and died with a Node `SyntaxError` at `/work/_run.js` -
+ * after paying for a project sync and a server round trip. The one shape we DO
+ * default is the unambiguous command line (`gipity sandbox run "node
+ * tests/game.test.js"`): it was the single most common rejected invocation,
+ * the CLI had everything it needed to run it, and no code snippet matches the
+ * heuristic. Ambiguous snippets still fail here, costing nothing and saying
+ * what to type. (`docs/skills/sandbox-tools.md` used to carry a hand-written
+ * "always pin the language" warning to work around this; the CLI enforces it
+ * now.)
  */
 export function resolveLanguage(opts) {
     const explicit = opts.langFromInterp
@@ -68,6 +106,8 @@ export function resolveLanguage(opts) {
         console.error(dim(`Pass --language explicitly:\n  gipity sandbox run --language py --file ${opts.filePath}`));
         process.exit(1);
     }
+    if (opts.inlineCode && looksLikeShellCommand(opts.inlineCode))
+        return 'bash';
     console.error(clrError('No language specified for inline code.'));
     console.error(dim(`Pin it one of three ways:\n${PIN_LANGUAGE_HELP}`));
     process.exit(1);
@@ -129,6 +169,11 @@ sandboxCommand
     .option('--file <path>', 'Read the code body from a file instead of the inline <code> arg; --language is inferred from the extension when not given')
     .option('--timeout <seconds>', 'Execution timeout in seconds', '30')
     .option('--input <path>', 'Narrow to specific project files instead of auto-mirroring the whole tree (repeatable). Use this only for >1 GB projects or when you want surgical control.', (v, prev) => [...(prev ?? []), v])
+    // Commander maps a `--no-` prefixed flag to the un-prefixed camelCase name
+    // (`opts.syncOutput`); the explicit `[]` default stops commander's negated-
+    // boolean convention from defaulting it to `true`. Collected as an array so
+    // the flag is repeatable.
+    .option('--no-sync-output <glob>', 'Do not persist run outputs matching this glob back to the project (repeatable). For byproducts you want to inspect once but never keep, e.g. --no-sync-output "docs/preview*". Supports *, **, and dir/ prefixes.', (v, prev) => [...prev, v], [])
     .option('--json', 'Output as JSON')
     .addHelpText('after', `
 By default the whole project is auto-mirrored into /work/ (up to 1 GB) -
@@ -217,11 +262,19 @@ GCC/Rust).
             process.exit(1);
         }
     }
-    // Language precedence: interpreter token > --language > file extension.
-    // There is deliberately no fallback: resolveLanguage() exits when nothing
-    // pinned one, rather than guessing. This runs BEFORE the project sync and the
-    // server round trip below, so a missing language costs nothing but the message.
-    const language = resolveLanguage({ langFromInterp, langOpt: opts.language, filePath });
+    // Language precedence: interpreter token > --language > file extension >
+    // unambiguous-command-line heuristic (bash). resolveLanguage() exits when
+    // nothing pins one and the input isn't command-shaped, rather than guessing.
+    // This runs BEFORE the project sync and the server round trip below, so a
+    // missing language costs nothing but the message.
+    const language = resolveLanguage({ langFromInterp, langOpt: opts.language, filePath, inlineCode });
+    // Validate --no-sync-output globs while we're still pre-network: an empty
+    // pattern (e.g. a quoting mishap) would silently match nothing server-side.
+    const noSyncOutput = opts.syncOutput ?? [];
+    if (noSyncOutput.some((g) => !g.trim())) {
+        console.error(clrError('--no-sync-output requires a non-empty glob (e.g. --no-sync-output "docs/preview*")'));
+        process.exit(1);
+    }
     // Args are good - now it's worth resolving (and announcing) the project.
     const { config } = await resolveProjectContext();
     const timeout = parseInt(opts.timeout, 10);
@@ -256,6 +309,10 @@ GCC/Rust).
         timeout: isNaN(timeout) ? 30 : timeout,
         input_files: opts.input,
         cwd,
+        // The filter must run SERVER-side (in the output extractor): skipping
+        // only in the CLI would still write the files into project storage and
+        // make every later sync propose deleting them.
+        noSyncOutput: noSyncOutput.length ? noSyncOutput : undefined,
     });
     const res = opts.json
         ? await doRun()
@@ -292,6 +349,11 @@ GCC/Rust).
             for (const f of res.data.outputFiles)
                 console.log(`${f}`);
         }
+        if (res.data.skippedOutputFiles && res.data.skippedOutputFiles.length > 0) {
+            console.log(dim('\nNot persisted (--no-sync-output):'));
+            for (const f of res.data.skippedOutputFiles)
+                console.log(dim(`${f}`));
+        }
         if (res.data.exitCode !== 0) {
             // No "did you mean another language?" hint is needed: the language is now
             // always something the caller pinned, never a silent default we chose.

package/dist/commands/test.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { get, post } from '../api.js';
-import { requireConfig } from '../config.js';
+import { requireConfig, getProjectRoot } from '../config.js';
 import { success, error as clrError, warning, muted, bold, dim } from '../colors.js';
 import { run, syncBeforeAction } from '../helpers/index.js';
 // Absolute poll ceiling - the server reaps stalled runs (~65 min) well before
@@ -15,6 +15,22 @@ function statusIcon(status) {
         return muted('→');
     return muted('?');
 }
+/** When the runner finds nothing, list the test-looking files it deliberately
+ *  skipped (kit tests under src/packages/, .spec.* files) so "no tests" never
+ *  contradicts what's on disk, and point at the sandbox as the way to run
+ *  frontend/kit module tests (cli#120/cli#121). */
+function printSkippedCandidates(skipped) {
+    if (skipped.length === 0)
+        return;
+    console.log('');
+    console.log(muted(`Found ${skipped.length} test-looking file${skipped.length === 1 ? '' : 's'} that gipity test does not run:`));
+    for (const s of skipped.slice(0, 10)) {
+        console.log(muted(`  ${s.path} (${s.reason})`));
+    }
+    if (skipped.length > 10)
+        console.log(muted(`  ... and ${skipped.length - 10} more`));
+    console.log(muted('Run frontend/kit module tests in the sandbox: gipity sandbox run bash "node <file>"'));
+}
 // Long-run hint for non-TTY runs: after this, print a one-time "not hung" + faster-path hint.
 const LONG_RUN_MS = 60000;
 async function pollTestStatus(projectGuid, runGuid, opts) {
@@ -169,15 +185,40 @@ export const testCommand = new Command('test')
         process.exit(1);
     }
     if (!filterPath && data.total === 0 && data.results.length === 0) {
-        console.log(muted('No tests ran - this app has no tests/*.test.js files.'));
+        // Name the searched root: discovery is server-side over the synced
+        // project tree's tests/, never the shell cwd - an agent running from a
+        // subdirectory must not read this as "the project has no tests" for
+        // the wrong reason (cli#120).
+        const root = getProjectRoot();
+        console.log(muted(`No tests ran - no tests/*.test.js files under the project root${root ? ` (${root})` : ''}.`));
         console.log(muted('gipity test runs server-function tests only; a frontend-only app (no functions/) has nothing here to run.'));
         console.log(muted('Verify a frontend app by driving the live page: gipity page inspect <url> (or gipity page eval).'));
+        // Enumerate test-looking files the runner deliberately skips (kit
+        // tests, .spec.*) so this answer never contradicts what's on disk.
+        try {
+            const listRes = await get(`/projects/${config.projectGuid}/test/list`);
+            printSkippedCandidates(listRes.data.skipped ?? []);
+        }
+        catch { /* the skipped list is advisory - never fail the run over it */ }
         return;
     }
     if (data.status === 'failed' && data.errorMessage) {
         console.log(clrError(`Run failed: ${data.errorMessage}`));
         console.log('');
     }
+    // Failures recap. Results stream incrementally above, but agents usually
+    // read this output through a `tail` window, so anything printed early is
+    // lost - restate every failure (name + assertion message) right before
+    // the summary, where it's guaranteed to survive truncation from the top.
+    if (data.failed > 0) {
+        console.log(clrError('Failures:'));
+        for (const r of data.results.filter(r => r.status === 'failed')) {
+            const where = r.path ? `${r.path}/` : '';
+            console.log(`  ${statusIcon('failed')} ${where}${r.name || '(unnamed test - the file may have crashed outside a test)'}`);
+            console.log(`      ${clrError(r.error || `(no assertion message recorded - inspect with: gipity test status ${runGuid} --json)`)}`);
+        }
+        console.log('');
+    }
     // Summary
     const parts = [];
     if (data.passed > 0)
@@ -255,9 +296,17 @@ testCommand
         return;
     }
     if (total === 0) {
+        // Discovery is server-side over the synced project tree's tests/ -
+        // never the shell cwd. Say which root was searched so this can't be
+        // misread as a definitive project-level fact from a subdirectory
+        // (cli#120), and list any test-looking files deliberately skipped
+        // (kit tests, .spec.*) instead of asserting none exist (cli#121).
+        const root = getProjectRoot();
         console.log(muted(pathFilter
             ? `No test files matched filter: ${pathFilter}`
-            : 'No test files found. Add *.test.js files under tests/.'));
+            : `No test files found under tests/ at the project root${root ? ` (${root})` : ''}. Add *.test.js files under tests/.`));
+        if (!pathFilter)
+            printSkippedCandidates(res.data.skipped ?? []);
         return;
     }
     console.log(bold(`Test files${pathFilter ? ` (filter: ${pathFilter})` : ''}: ${total}`));

package/dist/commands/workflow.js

@@ -29,6 +29,25 @@ 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))}`;
 }
+/** 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. */
+function printStepRuns(steps, emptyNote) {
+    if (steps.length === 0) {
+        console.log(`  ${muted(emptyNote)}`);
+        return;
+    }
+    for (const s of steps) {
+        const statusColor = s.status === 'completed' ? success : s.status === 'failed' ? clrError : muted;
+        const model = s.model_used ? `  ${muted(`[${s.model_used}]`)}` : '';
+        console.log(`  ${s.step_order}. ${statusColor(s.status)}  ${s.tokens_used ?? 0} tokens${model}`);
+        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'));
+        }
+    }
+}
 const TERMINAL_RUN_STATUSES = new Set(['completed', 'failed', 'cancelled']);
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 /**
@@ -155,6 +174,10 @@ workflowCommand
         console.log(formatRunLine(r));
         if (r.error_message)
             console.log(`  ${clrError(r.error_message)}`);
+        // The whole point of --wait is to see what the run did. The detail endpoint
+        // we just polled already carries the steps, so show them rather than make
+        // the caller re-query the database to find out whether anything happened.
+        printStepRuns(r.step_runs ?? [], '(no steps recorded)');
     }
     if (r.status !== 'completed')
         process.exit(1);
@@ -176,22 +199,7 @@ workflowCommand
             return;
         }
         console.log(formatRunLine(r));
-        const steps = r.step_runs ?? [];
-        if (steps.length === 0) {
-            console.log('  (no steps recorded)');
-            return;
-        }
-        for (const s of steps) {
-            const statusColor = s.status === 'completed' ? success : s.status === 'failed' ? clrError : muted;
-            const model = s.model_used ? `  ${muted(`[${s.model_used}]`)}` : '';
-            console.log(`  ${s.step_order}. ${statusColor(s.status)}  ${s.tokens_used ?? 0} tokens${model}`);
-            if (s.error_message)
-                console.log(`     ${clrError(s.error_message)}`);
-            if (s.output_json !== null && s.output_json !== undefined) {
-                const pretty = JSON.stringify(s.output_json, null, 2).split('\n').map(l => `     ${l}`).join('\n');
-                console.log(pretty);
-            }
-        }
+        printStepRuns(r.step_runs ?? [], '(no steps recorded)');
         return;
     }
     const res = await get(`/workflows/${wf.short_guid}/runs`);

package/dist/helpers/sync.js

@@ -1,7 +1,7 @@
 /**
  * sync.ts - Shared sync-before-action helper.
  */
-import { sync } from '../sync.js';
+import { sync, isLocalTreeClean } from '../sync.js';
 import { muted, error as clrError } from '../colors.js';
 import { createProgressReporter } from '../progress.js';
 /**
@@ -15,6 +15,13 @@ import { createProgressReporter } from '../progress.js';
 export async function syncBeforeAction(opts) {
     if (opts.sync === false)
         return;
+    // Nothing changed locally since the last sync → nothing to push, and the
+    // action (deploy etc.) reads server-side state anyway. Skip the whole sync
+    // round trip. The probe is local-only stat checks and conservative: any
+    // doubt (size/mtime moved, never synced, no baseline) falls through to a
+    // real sync. `--force` always takes the full path.
+    if (!opts.force && isLocalTreeClean())
+        return;
     // Pass a progress reporter so a large pre-action upload shows the transfer
     // bar instead of a silent pause (the reporter is a no-op on non-TTY / when
     // piped, so JSON and headless output stay clean).