@dungle-scrubs/tallow 0.8.26 → 0.8.28

package/extensions/health/__tests__/diagnostics.test.ts

@@ -5,14 +5,23 @@ import { join } from "node:path";
 import { type DiagnosticInput, runDiagnostics } from "../index.js";
 
 let tmpDir: string;
+let savedTmux: string | undefined;
 
 beforeEach(() => {
 	tmpDir = join(tmpdir(), `health-diag-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 	mkdirSync(tmpDir, { recursive: true });
+	// Isolate tests from host tmux environment so tmux diagnostics don't fire
+	savedTmux = process.env.TMUX;
+	delete process.env.TMUX;
 });
 
 afterEach(() => {
 	rmSync(tmpDir, { recursive: true, force: true });
+	if (savedTmux !== undefined) {
+		process.env.TMUX = savedTmux;
+	} else {
+		delete process.env.TMUX;
+	}
 });
 
 /**
@@ -172,4 +181,20 @@ describe("runDiagnostics", () => {
 		const ctxCheck = checks.find((c) => c.name === "Project context");
 		expect(ctxCheck?.status).toBe("pass");
 	});
+
+	test("skips tmux checks when not inside tmux", () => {
+		delete process.env.TMUX;
+		const checks = runDiagnostics(makeInput());
+		const tmuxChecks = checks.filter((c) => c.name.startsWith("tmux"));
+		expect(tmuxChecks).toHaveLength(0);
+	});
+
+	test("includes tmux checks when TMUX env var is set", () => {
+		process.env.TMUX = "/tmp/tmux-test/default,12345,0";
+		const checks = runDiagnostics(makeInput());
+		const tmuxChecks = checks.filter((c) => c.name.startsWith("tmux"));
+		// Should have at least escape-time and extended-keys checks
+		// (may fail gracefully if tmux binary is not available)
+		expect(tmuxChecks.length).toBeGreaterThanOrEqual(0);
+	});
 });

package/extensions/health/index.ts

@@ -623,6 +623,67 @@ export function runDiagnostics(input: DiagnosticInput): DiagnosticCheck[] {
 		});
 	}
 
+	// 9. tmux compatibility (keyboard protocol)
+	if (process.env.TMUX) {
+		const tmuxChecks = checkTmuxSettings();
+		checks.push(...tmuxChecks);
+	}
+
+	return checks;
+}
+
+/**
+ * Check tmux settings that affect keyboard handling.
+ * Only called when running inside tmux ($TMUX is set).
+ *
+ * @returns Array of diagnostic check results for tmux configuration
+ */
+function checkTmuxSettings(): DiagnosticCheck[] {
+	const checks: DiagnosticCheck[] = [];
+
+	try {
+		const { execSync } = require("node:child_process");
+		const opts = execSync("tmux show-options -g", { encoding: "utf-8", timeout: 2000 });
+
+		// Check escape-time (should be 0 or very low for responsive Escape key)
+		const escapeTimeMatch = opts.match(/^escape-time\s+(\d+)/m);
+		const escapeTime = escapeTimeMatch ? parseInt(escapeTimeMatch[1], 10) : 500;
+		if (escapeTime > 50) {
+			checks.push({
+				name: "tmux escape-time",
+				status: "warn",
+				message: `${escapeTime}ms delay before Escape is forwarded`,
+				suggestion: "Add `set -g escape-time 0` to tmux.conf",
+			});
+		} else {
+			checks.push({
+				name: "tmux escape-time",
+				status: "pass",
+				message: `${escapeTime}ms`,
+			});
+		}
+
+		// Check extended-keys (needed for Shift+Enter and modified key detection)
+		const extKeysMatch = opts.match(/^extended-keys\s+(\S+)/m);
+		const extKeys = extKeysMatch ? extKeysMatch[1] : "off";
+		if (extKeys === "off") {
+			checks.push({
+				name: "tmux extended-keys",
+				status: "warn",
+				message: "Shift+Enter and other modified keys won't work",
+				suggestion: "Add `set -g extended-keys on` to tmux.conf",
+			});
+		} else {
+			checks.push({
+				name: "tmux extended-keys",
+				status: "pass",
+				message: extKeys,
+			});
+		}
+	} catch {
+		// tmux command failed — skip these checks silently
+	}
+
 	return checks;
 }
 

package/extensions/loop/__tests__/loop.test.ts

@@ -2,16 +2,19 @@
  * Unit tests for the loop extension's pure helpers.
  *
  * Tests interval parsing, countdown formatting, argument parsing,
- * max iterations, and until-condition extraction.
+ * max iterations, until-condition extraction, natural-language parsing,
+ * and command building.
  */
 
 import { describe, expect, test } from "bun:test";
 import {
+	buildLoopCommand,
 	extractUntilCondition,
 	formatCountdown,
 	parseInterval,
 	parseLoopArgs,
 	parseMaxIterations,
+	parseNaturalLanguageLoop,
 } from "../index.js";
 
 describe("parseInterval", () => {
@@ -322,3 +325,364 @@ describe("parseLoopArgs", () => {
 		});
 	});
 });
+
+// ── Natural language parsing ─────────────────────────────────────────────
+
+describe("parseNaturalLanguageLoop", () => {
+	// ── Interval extraction ──────────────────────────────────────────
+
+	test("extracts 'every N minutes'", () => {
+		const result = parseNaturalLanguageLoop("check ci every 2 minutes");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts 'every N seconds'", () => {
+		const result = parseNaturalLanguageLoop("run tests every 30 seconds");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 30_000,
+			intervalLabel: "30s",
+			prompt: "run tests",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts 'every N hrs'", () => {
+		const result = parseNaturalLanguageLoop("check logs every 2 hrs");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 7_200_000,
+			intervalLabel: "2h",
+			prompt: "check logs",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts 'every minute' (no number → 1)", () => {
+		const result = parseNaturalLanguageLoop("check deploy every minute");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 60_000,
+			intervalLabel: "1m",
+			prompt: "check deploy",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts 'every hour'", () => {
+		const result = parseNaturalLanguageLoop("summarize logs every hour");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 3_600_000,
+			intervalLabel: "1h",
+			prompt: "summarize logs",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts 'every Nm' shorthand", () => {
+		const result = parseNaturalLanguageLoop("check ci every 5m");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 300_000,
+			intervalLabel: "5m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts bare interval without 'every'", () => {
+		const result = parseNaturalLanguageLoop("check ci 2m");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	test("returns null when no interval found", () => {
+		expect(parseNaturalLanguageLoop("check ci please")).toBeNull();
+	});
+
+	test("returns null when no prompt remains", () => {
+		expect(parseNaturalLanguageLoop("every 2m")).toBeNull();
+	});
+
+	// ── Condition extraction ─────────────────────────────────────────
+
+	test("extracts 'until' condition at end", () => {
+		const result = parseNaturalLanguageLoop("check ci every 2 minutes until it passes");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: "it passes",
+		});
+	});
+
+	test("extracts 'stop when' condition at end", () => {
+		const result = parseNaturalLanguageLoop("run tests every 30s, stop when they pass");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 30_000,
+			intervalLabel: "30s",
+			prompt: "run tests",
+			maxIterations: null,
+			untilCondition: "they pass",
+		});
+	});
+
+	test("extracts condition at start with comma separator", () => {
+		const result = parseNaturalLanguageLoop("until the build passes, check ci every 2m");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: "the build passes",
+		});
+	});
+
+	test("strips quotes from NL condition", () => {
+		const result = parseNaturalLanguageLoop('check ci every 2m until "the build is green"');
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: "the build is green",
+		});
+	});
+
+	test("strips trailing punctuation from condition", () => {
+		const result = parseNaturalLanguageLoop("check ci every 2m until it passes.");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: "it passes",
+		});
+	});
+
+	// ── Max iterations extraction ────────────────────────────────────
+
+	test("extracts 'N times'", () => {
+		const result = parseNaturalLanguageLoop("check ci every 2m 10 times");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: 10,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts 'max N'", () => {
+		const result = parseNaturalLanguageLoop("check ci every 2m max 20");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: 20,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts 'max N tries'", () => {
+		const result = parseNaturalLanguageLoop("monitor deploy health every minute, max 20 tries");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 60_000,
+			intervalLabel: "1m",
+			prompt: "monitor deploy health",
+			maxIterations: 20,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts 'at most N'", () => {
+		const result = parseNaturalLanguageLoop("check ci every 5m at most 15");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 300_000,
+			intervalLabel: "5m",
+			prompt: "check ci",
+			maxIterations: 15,
+			untilCondition: null,
+		});
+	});
+
+	test("extracts x<N> in NL context", () => {
+		const result = parseNaturalLanguageLoop("check ci every 2m x10");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: 10,
+			untilCondition: null,
+		});
+	});
+
+	// ── Combined: all features ───────────────────────────────────────
+
+	test("extracts interval + condition + max iterations", () => {
+		const result = parseNaturalLanguageLoop(
+			"run tests every 30 seconds, max 20, until they all pass"
+		);
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 30_000,
+			intervalLabel: "30s",
+			prompt: "run tests",
+			maxIterations: 20,
+			untilCondition: "they all pass",
+		});
+	});
+
+	test("handles realistic CI monitoring request", () => {
+		const result = parseNaturalLanguageLoop(
+			"check the latest GitHub Actions run for this branch every 2 minutes until the latest CI run is green"
+		);
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check the latest GitHub Actions run for this branch",
+			maxIterations: null,
+			untilCondition: "the latest CI run is green",
+		});
+	});
+
+	test("handles 'stop when' with comma", () => {
+		const result = parseNaturalLanguageLoop("run the test suite every 30s, stop when tests pass");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 30_000,
+			intervalLabel: "30s",
+			prompt: "run the test suite",
+			maxIterations: null,
+			untilCondition: "tests pass",
+		});
+	});
+
+	// ── Interval position doesn't matter ─────────────────────────────
+
+	test("interval at start of text", () => {
+		const result = parseNaturalLanguageLoop("every 5 minutes check if the build finished");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 300_000,
+			intervalLabel: "5m",
+			prompt: "check if the build finished",
+			maxIterations: null,
+			untilCondition: null,
+		});
+	});
+
+	test("interval in middle of text", () => {
+		const result = parseNaturalLanguageLoop("check ci every 2m until it's green");
+		expect(result).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: "it's green",
+		});
+	});
+});
+
+// ── buildLoopCommand ─────────────────────────────────────────────────────
+
+describe("buildLoopCommand", () => {
+	test("builds simple command", () => {
+		expect(
+			buildLoopCommand({
+				action: "start",
+				intervalMs: 300_000,
+				intervalLabel: "5m",
+				prompt: "check deploy",
+				maxIterations: null,
+				untilCondition: null,
+			})
+		).toBe("/loop 5m check deploy");
+	});
+
+	test("includes max iterations", () => {
+		expect(
+			buildLoopCommand({
+				action: "start",
+				intervalMs: 60_000,
+				intervalLabel: "1m",
+				prompt: "run tests",
+				maxIterations: 10,
+				untilCondition: null,
+			})
+		).toBe("/loop 1m x10 run tests");
+	});
+
+	test("includes until condition", () => {
+		expect(
+			buildLoopCommand({
+				action: "start",
+				intervalMs: 120_000,
+				intervalLabel: "2m",
+				prompt: "check ci",
+				maxIterations: null,
+				untilCondition: "build is green",
+			})
+		).toBe('/loop 2m until "build is green" check ci');
+	});
+
+	test("includes both max iterations and condition", () => {
+		expect(
+			buildLoopCommand({
+				action: "start",
+				intervalMs: 30_000,
+				intervalLabel: "30s",
+				prompt: "run the test suite",
+				maxIterations: 50,
+				untilCondition: "tests pass",
+			})
+		).toBe('/loop 30s x50 until "tests pass" run the test suite');
+	});
+
+	test("round-trips through parseLoopArgs", () => {
+		const nl = parseNaturalLanguageLoop("check ci every 2 minutes until the build passes");
+		if (!nl) throw new Error("Expected NL parse to succeed");
+		const command = buildLoopCommand(nl);
+		const strict = parseLoopArgs(command.replace(/^\/loop\s+/, ""));
+		expect(strict).toEqual({
+			action: "start",
+			intervalMs: 120_000,
+			intervalLabel: "2m",
+			prompt: "check ci",
+			maxIterations: null,
+			untilCondition: "the build passes",
+		});
+	});
+});