/**
* Use Case Tests — Real-world scenarios using static fixtures
*
* Each use case represents a common task where Claude Code
* would benefit from context-mode instead of raw Read/cat.
*/
import { strict as assert } from "node:assert";
import { PolyglotExecutor } from "../src/executor.js";
import { detectRuntimes, getRuntimeSummary } from "../src/runtime.js";
import { readFileSync } from "node:fs";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";
const __dirname = dirname(fileURLToPath(import.meta.url));
const fixtureDir = join(__dirname, "fixtures");
const runtimes = detectRuntimes();
const executor = new PolyglotExecutor({ runtimes });
let passed = 0;
let failed = 0;
async function useCase(
name: string,
fixture: string,
fn: (filePath: string) => Promise<void>,
) {
const filePath = join(fixtureDir, fixture);
const rawSize = readFileSync(filePath).byteLength;
console.log(`\n--- ${name} ---`);
console.log(` Fixture: ${fixture} (${(rawSize / 1024).toFixed(1)}KB)`);
try {
await fn(filePath);
passed++;
console.log(` Status: PASS`);
} catch (err: any) {
failed++;
console.log(` Status: FAIL — ${err.message}`);
}
}
async function main() {
console.log("Context Mode — Use Case Tests (Fixtures)");
console.log("=========================================\n");
console.log("Runtimes:\n" + getRuntimeSummary(runtimes));
// ===== UC1: Triage failing tests =====
await useCase(
"UC1: Triage failing tests from vitest output",
"test-output.txt",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const lines = FILE_CONTENT.split("\\n");
const failSuites = lines.filter(l => l.match(/^\\s*\\u2717/) && !l.match(/^\\s{4,}/));
const failTests = lines.filter(l => l.match(/^\\s{3,}\\u2717/));
const passTests = lines.filter(l => l.match(/^\\s{3,}\\u2713/));
console.log("Suites:", failSuites.length, "failed out of", failSuites.length + lines.filter(l => l.match(/^\\s*\\u2713/) && !l.match(/^\\s{4,}/)).length);
console.log("Tests:", passTests.length, "passed,", failTests.length, "failed");
if (failTests.length) {
console.log("\\nFailing tests:");
let currentFile = "";
lines.forEach((l, i) => {
if (l.match(/^\\s*\\u2717/) && !l.match(/^\\s{4,}/)) currentFile = l.trim();
if (l.match(/^\\s{3,}\\u2717/)) {
console.log(" " + currentFile);
console.log(" " + l.trim());
// Show error details (next few lines)
for (let j = i+1; j < Math.min(i+4, lines.length); j++) {
const next = lines[j].trim();
if (next.startsWith("\\u2192") || next.startsWith("expected") || next.startsWith("received")) {
console.log(" " + next);
}
}
}
});
}
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("failed"), "Should report failures");
console.log(" Output: " + r.stdout.trim().split("\n").length + " lines");
},
);
// ===== UC2: Diagnose TypeScript errors =====
await useCase(
"UC2: Diagnose TypeScript errors by file and type",
"tsc-errors.txt",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const lines = FILE_CONTENT.trim().split("\\n").filter(l => l.includes("error TS"));
const byFile = {};
const byCode = {};
lines.forEach(l => {
const file = l.split("(")[0];
const code = l.match(/TS\\d+/)?.[0] || "?";
const msg = l.split(": error ")[1] || l;
byFile[file] = byFile[file] || [];
byFile[file].push(code);
byCode[code] = (byCode[code] || 0) + 1;
});
console.log("Total:", lines.length, "errors in", Object.keys(byFile).length, "files\\n");
console.log("By file:");
Object.entries(byFile).sort((a,b) => b[1].length - a[1].length).forEach(([f, codes]) => {
console.log(" " + f + ": " + codes.length + " (" + [...new Set(codes)].join(", ") + ")");
});
console.log("\\nMost common:");
Object.entries(byCode).sort((a,b) => b[1]-a[1]).slice(0,5).forEach(([c,n]) => console.log(" " + c + ": " + n + "x"));
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("errors"), "Should report error count");
},
);
// ===== UC3: Review git diff =====
await useCase(
"UC3: Summarize git diff for code review",
"git-diff.patch",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const content = FILE_CONTENT;
const files = content.split("diff --git").slice(1);
let totalAdd = 0, totalDel = 0;
console.log("Code Review Summary (" + files.length + " files changed):\\n");
files.forEach(section => {
const name = section.match(/b\\/(\\S+)/)?.[1] || "unknown";
const lines = section.split("\\n");
const added = lines.filter(l => l.startsWith("+") && !l.startsWith("+++"));
const deleted = lines.filter(l => l.startsWith("-") && !l.startsWith("---"));
totalAdd += added.length;
totalDel += deleted.length;
// Detect change type
const hasNewFn = added.some(l => l.includes("function ") || l.includes("class ") || l.includes("=> {"));
const hasRemoved = deleted.length > added.length;
const type = hasNewFn ? "feature" : hasRemoved ? "cleanup" : "modification";
console.log(" " + name + " [" + type + "] +" + added.length + " -" + deleted.length);
});
console.log("\\nTotal: +" + totalAdd + " -" + totalDel + " (" + (totalAdd + totalDel) + " lines touched)");
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("files changed"), "Should list changed files");
},
);
// ===== UC4: Analyze server access patterns =====
await useCase(
"UC4: Analyze access log for performance issues",
"access.log",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const lines = FILE_CONTENT.trim().split("\\n");
const stats = { total: lines.length, errors: 0, slow: 0, endpoints: {}, methods: {} };
let totalMs = 0;
lines.forEach(l => {
const status = l.match(/" (\\d+) /)?.[1];
const method = l.match(/"(\\w+) /)?.[1];
const path = l.match(/"\\w+ (\\S+)/)?.[1];
const ms = l.match(/(\\d+)ms$/)?.[1];
if (status && +status >= 400) stats.errors++;
if (ms) { totalMs += +ms; if (+ms > 1000) stats.slow++; }
if (method) stats.methods[method] = (stats.methods[method]||0) + 1;
if (path) stats.endpoints[path] = (stats.endpoints[path]||0) + 1;
});
console.log("Traffic: " + stats.total + " requests");
console.log("Errors: " + stats.errors + " (" + ((stats.errors/stats.total)*100).toFixed(1) + "%)");
console.log("Slow (>1s): " + stats.slow);
console.log("Avg latency: " + Math.round(totalMs/stats.total) + "ms");
console.log("\\nMethods:", Object.entries(stats.methods).map(([m,c])=>m+":"+c).join(" "));
console.log("Top endpoints:");
Object.entries(stats.endpoints).sort((a,b)=>b[1]-a[1]).slice(0,5).forEach(([p,c]) => console.log(" " + p + ": " + c));
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("requests"), "Should report request count");
},
);
// ===== UC5: Audit dependencies =====
await useCase(
"UC5: Audit package.json for dependency overview",
"package-large.json",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const pkg = JSON.parse(FILE_CONTENT);
const deps = Object.entries(pkg.dependencies || {});
const devDeps = Object.entries(pkg.devDependencies || {});
console.log(pkg.name + "@" + pkg.version);
console.log("\\nDependencies (" + deps.length + "):");
// Group by category
const ui = deps.filter(([n]) => n.includes("radix") || n.includes("lucide") || n.includes("tailwind") || n.includes("cva") || n.includes("clsx"));
const data = deps.filter(([n]) => n.includes("prisma") || n.includes("trpc") || n.includes("tanstack"));
const auth = deps.filter(([n]) => n.includes("auth"));
const infra = deps.filter(([n]) => n.includes("stripe") || n.includes("resend") || n.includes("upload"));
console.log(" UI: " + ui.map(([n])=>n).join(", "));
console.log(" Data: " + data.map(([n])=>n).join(", "));
console.log(" Auth: " + auth.map(([n])=>n).join(", "));
console.log(" Services: " + infra.map(([n])=>n).join(", "));
console.log("\\nDevDependencies (" + devDeps.length + "): " + devDeps.map(([n])=>n).join(", "));
console.log("\\nScripts: " + Object.keys(pkg.scripts||{}).join(", "));
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("Dependencies"), "Should list deps");
},
);
// ===== UC6: Analyze build errors =====
await useCase(
"UC6: Triage build output — find errors and warnings",
"build-output.txt",
async (path) => {
const r = await executor.executeFile({
path,
language: "shell",
code: `
total=$(echo "$FILE_CONTENT" | wc -l | tr -d ' ')
errors=$(echo "$FILE_CONTENT" | grep -c "ERROR\\|error TS" || true)
warnings=$(echo "$FILE_CONTENT" | grep -ci "warning" || true)
compiled=$(echo "$FILE_CONTENT" | grep -c "Compiled\\|compiled\\|✓" || true)
echo "Build Summary ($total lines):"
echo " Compiled: $compiled"
echo " Warnings: $warnings"
echo " Errors: $errors"
if [ "$errors" -gt 0 ]; then
echo ""
echo "Errors:"
echo "$FILE_CONTENT" | grep "ERROR\\|error TS" | head -5 | while read line; do
echo " $line"
done
fi
if [ "$warnings" -gt 0 ]; then
echo ""
echo "Warnings (first 3):"
echo "$FILE_CONTENT" | grep -i "warning" | head -3 | while read line; do
echo " $line"
done
fi
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("Build Summary"), "Should have summary");
},
);
// ===== UC7: MCP tool discovery =====
await useCase(
"UC7: Discover MCP server capabilities",
"mcp-tools.json",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const tools = JSON.parse(FILE_CONTENT);
// Group by category (infer from name prefix)
const groups = {};
tools.forEach(t => {
const cat = t.name.split("_")[0] || "other";
if (!groups[cat]) groups[cat] = [];
groups[cat].push(t);
});
console.log("MCP Server: " + tools.length + " tools in " + Object.keys(groups).length + " categories\\n");
Object.entries(groups).forEach(([cat, tools]) => {
console.log(cat + " (" + tools.length + "):");
tools.forEach(t => {
const params = Object.keys(t.inputSchema?.properties || {});
console.log(" " + t.name + "(" + params.join(", ") + ")");
});
});
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("tools"), "Should list tools");
},
);
// ===== UC8: Understand source code structure =====
await useCase(
"UC8: Analyze TypeScript source code architecture",
"source-example.ts",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const lines = FILE_CONTENT.split("\\n");
const imports = [...FILE_CONTENT.matchAll(/^import .+ from "([^"]+)"/gm)].map(m => m[1]);
const interfaces = [...FILE_CONTENT.matchAll(/^(?:export )?interface\\s+(\\w+)/gm)].map(m => m[1]);
const types = [...FILE_CONTENT.matchAll(/^(?:export )?type\\s+(\\w+)/gm)].map(m => m[1]);
const classes = [...FILE_CONTENT.matchAll(/^export class\\s+(\\w+)/gm)].map(m => m[1]);
const funcs = [...FILE_CONTENT.matchAll(/^(?:export )?(?:async )?function\\s+(\\w+)/gm)].map(m => m[1]);
const schemas = [...FILE_CONTENT.matchAll(/const\\s+(\\w+Schema)/gm)].map(m => m[1]);
const routes = [...FILE_CONTENT.matchAll(/router\\.(get|post|put|delete|patch)\\("([^"]+)"/g)].map(m => m[1].toUpperCase() + " " + m[2]);
console.log("File: " + lines.length + " lines");
console.log("Imports: " + imports.join(", "));
console.log("Interfaces: " + interfaces.join(", "));
if (types.length) console.log("Types: " + types.join(", "));
console.log("Classes: " + classes.join(", "));
console.log("Functions: " + funcs.join(", "));
if (schemas.length) console.log("Zod schemas: " + schemas.join(", "));
if (routes.length) console.log("Routes: " + routes.join(", "));
// Complexity hint
const asyncFns = (FILE_CONTENT.match(/async /g) || []).length;
const tryCatch = (FILE_CONTENT.match(/try \\{/g) || []).length;
console.log("\\nComplexity: " + asyncFns + " async operations, " + tryCatch + " error handlers");
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("lines"), "Should report line count");
},
);
// ===== UC9: Git history analysis =====
await useCase(
"UC9: Analyze git log for team activity",
"git-log.txt",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const lines = FILE_CONTENT.trim().split("\\n");
const authors = {};
const types = {};
const daily = {};
lines.forEach(l => {
const parts = l.split(" ");
const date = parts[1];
const author = parts.slice(2, 4).join(" ");
const type = (parts[4] || "").replace(":", "");
authors[author] = (authors[author] || 0) + 1;
types[type] = (types[type] || 0) + 1;
daily[date] = (daily[date] || 0) + 1;
});
const dates = Object.keys(daily).sort();
console.log("Git History: " + lines.length + " commits");
console.log("Period: " + dates[0] + " to " + dates[dates.length-1]);
console.log("\\nContributors:");
Object.entries(authors).sort((a,b)=>b[1]-a[1]).forEach(([a,c]) => console.log(" " + a + ": " + c + " commits"));
console.log("\\nCommit types:");
Object.entries(types).sort((a,b)=>b[1]-a[1]).forEach(([t,c]) => console.log(" " + t + ": " + c));
console.log("\\nBusiest days:");
Object.entries(daily).sort((a,b)=>b[1]-a[1]).slice(0,3).forEach(([d,c]) => console.log(" " + d + ": " + c + " commits"));
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("commits"), "Should report commit count");
},
);
// ===== UC10: CSV analytics with Python =====
if (runtimes.python) {
await useCase(
"UC10: Analyze analytics CSV with Python",
"analytics.csv",
async (path) => {
const r = await executor.executeFile({
path,
language: "python",
code: `
import csv, io
from collections import Counter
reader = csv.DictReader(io.StringIO(FILE_CONTENT))
rows = list(reader)
actions = Counter(r["action"] for r in rows)
statuses = Counter(r["status"] for r in rows)
resources = Counter(r["resource"] for r in rows)
unique_users = len(set(r["user_id"] for r in rows))
errors = [r for r in rows if r["status"] in ("error", "timeout")]
durations = [int(r["duration_ms"]) for r in rows]
print(f"Analytics: {len(rows)} events from {unique_users} unique users")
print(f"Avg duration: {sum(durations)/len(durations):.0f}ms (max: {max(durations)}ms)")
print(f"Error rate: {len(errors)}/{len(rows)} ({len(errors)/len(rows)*100:.1f}%)")
print(f"\\nActions: {dict(actions.most_common())}")
print(f"Resources: {dict(resources.most_common())}")
print(f"Statuses: {dict(statuses.most_common())}")
# Find slowest actions
by_action_duration = {}
for r in rows:
a = r["action"]
by_action_duration.setdefault(a, []).append(int(r["duration_ms"]))
print(f"\\nSlowest (avg ms):")
for a, ds in sorted(by_action_duration.items(), key=lambda x: -sum(x[1])/len(x[1])):
print(f" {a}: {sum(ds)/len(ds):.0f}ms")
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("events"), "Should report event count");
},
);
}
// ===== UC11: API response processing =====
await useCase(
"UC11: Process API response — filter and aggregate",
"api-response.json",
async (path) => {
const r = await executor.executeFile({
path,
language: "javascript",
code: `
const users = JSON.parse(FILE_CONTENT);
const admins = users.filter(u => u.role === "admin");
const verified = users.filter(u => u.metadata.verified);
const byTheme = {};
const byLang = {};
users.forEach(u => {
const t = u.metadata.preferences.theme;
const l = u.metadata.preferences.language;
byTheme[t] = (byTheme[t]||0) + 1;
byLang[l] = (byLang[l]||0) + 1;
});
const avgLogins = users.reduce((s,u) => s + u.metadata.loginCount, 0) / users.length;
console.log("API Response: " + users.length + " users");
console.log("Roles: " + admins.length + " admins, " + (users.length - admins.length) + " users");
console.log("Verified: " + verified.length + "/" + users.length);
console.log("Avg login count: " + avgLogins.toFixed(0));
console.log("Themes: " + Object.entries(byTheme).map(([k,v])=>k+":"+v).join(", "));
console.log("Languages: " + Object.entries(byLang).map(([k,v])=>k+":"+v).join(", "));
console.log("\\nMost active:");
users.sort((a,b) => b.metadata.loginCount - a.metadata.loginCount).slice(0,3)
.forEach(u => console.log(" " + u.name + ": " + u.metadata.loginCount + " logins"));
`,
});
assert.equal(r.exitCode, 0, "Should exit 0: " + r.stderr);
assert.ok(r.stdout.includes("users"), "Should report user count");
},
);
// ===== SUMMARY =====
console.log("\n" + "=".repeat(60));
console.log(
`Use Cases: ${passed} passed, ${failed} failed (${passed + failed} total)`,
);
console.log("=".repeat(60));
if (failed > 0) process.exit(1);
}
main().catch((err) => {
console.error("Use case error:", err);
process.exit(1);
});
