codeply-cli 0.5.6 → 0.6.0

package/lib/design-library/make-table-data.mjs

@@ -1,39 +1,39 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const idx = JSON.parse(readFileSync(path.join(__dirname, 'index.json'), 'utf8'));
-
-const CATEGORY_LABELS = {
-  productivity: 'Productivity',
-  finance: 'Finance',
-  shopping: 'Shopping',
-  social: 'Social',
-  travel: 'Travel',
-  food_delivery: 'Food Delivery',
-  health_fitness: 'Health & Fitness',
-  education: 'Education',
-  entertainment: 'Entertainment',
-  real_estate: 'Real Estate',
-};
-
-const rows = [];
-for (const [cat, apps] of Object.entries(idx.categories)) {
-  for (const a of apps) {
-    rows.push({
-      n: a.name,
-      c: cat,
-      r: a.rating ? Math.round(a.rating * 10) / 10 : null,
-      rc: a.ratingCount || 0,
-      s: a.screenshots.length,
-      u: a.appStoreUrl,
-      i: a.icon,
-    });
-  }
-}
-rows.sort((x, y) => y.s - x.s);
-
-const out = { generatedAt: new Date().toISOString(), labels: CATEGORY_LABELS, rows };
-writeFileSync(path.join(__dirname, 'table-data.json'), JSON.stringify(out));
-console.log('rows:', rows.length);
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const idx = JSON.parse(readFileSync(path.join(__dirname, 'index.json'), 'utf8'));
+
+const CATEGORY_LABELS = {
+  productivity: 'Productivity',
+  finance: 'Finance',
+  shopping: 'Shopping',
+  social: 'Social',
+  travel: 'Travel',
+  food_delivery: 'Food Delivery',
+  health_fitness: 'Health & Fitness',
+  education: 'Education',
+  entertainment: 'Entertainment',
+  real_estate: 'Real Estate',
+};
+
+const rows = [];
+for (const [cat, apps] of Object.entries(idx.categories)) {
+  for (const a of apps) {
+    rows.push({
+      n: a.name,
+      c: cat,
+      r: a.rating ? Math.round(a.rating * 10) / 10 : null,
+      rc: a.ratingCount || 0,
+      s: a.screenshots.length,
+      u: a.appStoreUrl,
+      i: a.icon,
+    });
+  }
+}
+rows.sort((x, y) => y.s - x.s);
+
+const out = { generatedAt: new Date().toISOString(), labels: CATEGORY_LABELS, rows };
+writeFileSync(path.join(__dirname, 'table-data.json'), JSON.stringify(out));
+console.log('rows:', rows.length);

package/lib/design-tools.mjs

@@ -0,0 +1,173 @@
+/**
+ * Codeply's design layer: the two tools skills/codeply-taste/SKILL.md works with.
+ *
+ *   design_direction  deals an art direction from the skill's research library
+ *                     (scripts/draw.mjs): the script chooses, not the model, so
+ *                     designs don't all come out as the category default.
+ *   design_lint       checks a finished design: a static scan for the tells the
+ *                     skill bans (scripts/lint.mjs), then a real render. In Craft
+ *                     the render happens in Craft's own off-screen browser
+ *                     (ctx.browser.render), measured with the skill's probe and
+ *                     judged with its rules; the agent also gets screenshots.
+ *                     In the terminal there is no browser: the scan alone runs.
+ *
+ * The scripts are plain Node with no dependencies. They run through this
+ * process's own executable (Craft's, in Node mode), so nothing extra has to be
+ * installed.
+ */
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { probe, frame } from '../skills/codeply-taste/scripts/lib/probe.mjs';
+import { judge } from '../skills/codeply-taste/scripts/lib/rules.mjs';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPTS = path.join(HERE, '..', 'skills', 'codeply-taste', 'scripts');
+
+function runScript(script, argv, cwd, timeoutMs = 30000) {
+  return new Promise((resolve) => {
+    execFile(process.execPath, [path.join(SCRIPTS, script), ...argv], {
+      cwd, timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, windowsHide: true,
+      env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
+    }, (err, stdout, stderr) => resolve({
+      code: err ? (typeof err.code === 'number' ? err.code : 1) : 0,
+      out: String(stdout || '').trim(),
+      err: String(stderr || '').trim() || (err && !stdout ? err.message : ''),
+    }));
+  });
+}
+
+// Inside the design's own folder only: a design run never reaches into anything else.
+function insideCwd(p, cwd) {
+  const abs = path.resolve(cwd, String(p || ''));
+  const rel = path.relative(cwd, abs);
+  return rel && !rel.startsWith('..') && !path.isAbsolute(rel) ? abs : null;
+}
+
+const DIRECTION_FLAGS = ['sector', 'brief', 'tone', 'sections', 'have', 'keep', 'avoid', 'direction', 'redraw', 'list', 'site', 'seed'];
+
+export async function design_direction(args, ctx) {
+  const argv = [];
+  for (const k of DIRECTION_FLAGS) {
+    const v = args[k] == null ? '' : String(args[k]).trim();
+    if (v) argv.push(`--${k}`, v);
+  }
+  if (/^(1|true|yes|3)$/i.test(String(args.options || '').trim())) argv.push('--options', '3');
+  if (/^(1|true|yes)$/i.test(String(args.show || '').trim())) argv.push('--show');
+  if (!argv.length) {
+    return { ok: false, output: 'design_direction needs a <brief> and <sector> (or <direction>, <redraw>, <show>, <list>). Sectors: <list>sectors</list>.' };
+  }
+  argv.push('--out', path.join(ctx.cwd, '.taste-skill'));
+  const r = await runScript('draw.mjs', argv, ctx.cwd);
+  if (r.code !== 0 && !r.out) return { ok: false, output: `design_direction failed: ${r.err || 'no output'}` };
+  // The sheet suggests asset commands for a terminal; in Codeply, pictures come from image_search / fetch_image.
+  // Its wording is for a terminal: say it in this tool's parameters.
+  const text = r.out
+    .replace(/node \S*assets\.mjs/g, '(assets: use image_search, then fetch_image into assets/)')
+    .replace(/the same command plus `?--direction <id>`?(?: \(and without --options\))?/g, 'design_direction with direction=<id>')
+    .replace(/`?--(direction|redraw|options|keep|avoid|have|tone|sections|show)\b`?/g, '$1=')
+    .replace(/ ?\(SKILL\.md steps? [\d, and]+\)/g, '');
+  return { ok: true, output: text.slice(0, 24000), meta: { label: args.direction || args.redraw || args.sector || 'direction' } };
+}
+
+// What each kind of design is judged on. Rules about a web page's shape (a hero, a first
+// action, footage, pictures, motion while scrolling) don't apply to a slide or a document.
+const PAGE_RULES = ['no-hero', 'first-action', 'few-pictures', 'no-real-pictures', 'no-footage', 'still-page', 'empty-screens', 'long-pin', 'pinned-over-picture'];
+const KIND = {
+  website: { widths: [1440, 390], allow: [] },
+  app: { widths: [390], allow: [...PAGE_RULES, 'ui-wrapper', 'card-rows', 'pill-nav', 'icon-cards'] },
+  slides: { widths: [1280], height: 720, allow: [...PAGE_RULES, 'side-scroll', 'all-centred', 'measure'] },
+  doc: { widths: [816], height: 1056, allow: [...PAGE_RULES, 'all-centred'] },
+  poster: { widths: [1080], height: 1350, allow: [...PAGE_RULES, 'all-centred', 'side-scroll'] },
+  social: { widths: [1080], height: 1080, allow: [...PAGE_RULES, 'all-centred', 'side-scroll'] },
+  logo: { widths: [1200], height: 800, allow: [...PAGE_RULES, 'all-centred', 'font-count', 'size-count', 'body-size', 'small-text'] },
+};
+const MOBILE_H = 844;
+// A check takes a while and a model left to itself keeps checking: one when the
+// design is complete, one after fixing, and a third at most, per request.
+const MAX_CHECKS = 3;
+
+export async function design_lint(args, ctx) {
+  ctx.designChecks = (ctx.designChecks || 0) + 1;
+  if (ctx.designChecks > MAX_CHECKS) {
+    return {
+      ok: true,
+      output: `Not checked: that would be check ${ctx.designChecks} for this request, and ${MAX_CHECKS} is the most. Stop checking and write your summary now. If something still looks off, say what in one line; the person can ask for another pass.`,
+      meta: { label: 'skipped, checked enough' },
+    };
+  }
+  const file = insideCwd(args.path || 'index.html', ctx.cwd);
+  if (!file || !fs.existsSync(file)) return { ok: false, output: `design_lint: no such file in this design: ${args.path || 'index.html'}.` };
+  const kind = KIND[String(args.kind || 'website').trim().toLowerCase()] ? String(args.kind || 'website').trim().toLowerCase() : 'website';
+  const spec = KIND[kind];
+  const widths = String(args.widths || '').split(',').map((s) => parseInt(s, 10)).filter((n) => n >= 200 && n <= 2560);
+  const useWidths = widths.length ? widths.slice(0, 3) : spec.widths;
+
+  // Allowances: the kind's, the drawn direction's (draw.mjs grants some), and any the agent names with a reason.
+  let allow = [...spec.allow];
+  try { allow.push(...(JSON.parse(fs.readFileSync(path.join(ctx.cwd, '.taste-skill', 'direction.json'), 'utf8')).allow || [])); } catch {}
+  allow.push(...String(args.allow || '').split(',').map((s) => s.trim()).filter(Boolean));
+  allow = [...new Set(allow)];
+
+  const findings = [];
+  const scan = await runScript('lint.mjs', [file, '--json'], ctx.cwd);
+  try {
+    for (const f of JSON.parse(scan.out).findings || []) if (!allow.includes(f.id)) findings.push({ ...f, where: `${path.basename(f.file || file)}:${f.line || '?'}` });
+  } catch { if (scan.err) findings.push({ level: 'WARN', id: 'lint', message: `The static scan did not run: ${scan.err.slice(0, 200)}` }); }
+
+  const render = ctx.browser && typeof ctx.browser.render === 'function' ? ctx.browser.render : null;
+  const images = [];
+  const measured = [];
+  if (render) {
+    for (const w of useWidths) {
+      const h = spec.height || (w < 600 ? MOBILE_H : Math.round(w * 0.625));
+      const r = await render(pathToFileURL(file).href, { width: w, height: h, probe: probe.toString(), frame: frame.toString(), screens: kind === 'website' && w >= 1000 ? 4 : kind === 'doc' || kind === 'slides' ? 3 : 1 });
+      if (!r || !r.ok) { findings.push({ level: 'FAIL', id: 'render', width: w, message: `The design did not render at ${w}px: ${(r && r.error) || 'unknown error'}` }); continue; }
+      if (r.metrics && !r.metrics.error) {
+        for (const f of judge(r.metrics, { width: w, allow })) findings.push(f);
+        const m = r.metrics;
+        measured.push(`@${w}px: ${m.page ? `${m.page.screens} screen(s), ${m.page.words} words, ${m.page.img} images` : ''}${m.type ? ` · type ${m.type.families.filter((f) => f.share >= 0.02).map((f) => f.family).join(', ')}` : ''}${m.hero ? ` · headline ${m.hero.lines} line(s) at ${m.hero.size}px` : ''}`);
+      } else if (r.metrics && r.metrics.error) findings.push({ level: 'WARN', id: 'probe', width: w, message: `Could not measure at ${w}px: ${r.metrics.error}` });
+      const covered = [...new Map((r.frames || []).filter(Boolean).flatMap((f, i) => (f.covered || []).map((c) => [c.text, { ...c, screen: i + 1 }]))).values()];
+      if (covered.length && !allow.includes('covered-text')) findings.push({ level: 'FAIL', id: 'covered-text', width: w, message: 'Large text lies under another element: ' + covered.slice(0, 3).map((c) => `"${c.text}" (screen ${c.screen})`).join('; '), fix: 'Nothing may sit on top of a headline. Move the picture or raise the text above it with a ground.' });
+      for (const e of (r.consoleErrors || []).slice(0, 2)) findings.push({ level: 'WARN', id: 'console', width: w, message: `Console error: ${String(e).slice(0, 200)}` });
+      for (const img of r.images || []) if (images.length < 4) images.push(img);
+    }
+  }
+
+  // The same rule at several widths: keep the first, note the others.
+  const merged = [];
+  for (const f of findings) {
+    const same = merged.find((x) => x.id === f.id && x.level === f.level && f.id !== 'headline-lines');
+    if (same && f.width) { same.alsoAt = [...(same.alsoAt || []), f.width]; continue; }
+    merged.push(f);
+  }
+  const fails = merged.filter((f) => f.level === 'FAIL');
+  const warns = merged.filter((f) => f.level === 'WARN');
+  const lines = [`design_lint ${path.relative(ctx.cwd, file).split(path.sep).join('/')} as ${kind}${render ? ` at ${useWidths.join(', ')}px` : ' (static scan only: no browser here)'}`];
+  if (measured.length) lines.push(...measured);
+  for (const [title, list] of [['FAIL (fix every one)', fails], ['WARN (optional: fix the quick ones in the same edit as the FAILs, leave the rest; never check again just for a WARN)', warns]]) {
+    if (!list.length) continue;
+    lines.push('', title);
+    for (const f of list.slice(0, 20)) lines.push(`- [${f.id}]${f.width ? ` @${f.width}px` : ''}${f.alsoAt ? ` (+${f.alsoAt.join(', ')})` : ''}${f.where ? ` ${f.where}` : ''} ${f.message}${f.fix ? `\n  fix: ${f.fix}` : ''}`);
+  }
+  if (images.length) lines.push('', `${images.length} screenshot(s) attached.`);
+  // What to do next, so a clean result ends the checking instead of starting more.
+  if (!fails.length) {
+    lines.push('', `It passes (check ${ctx.designChecks} of ${MAX_CHECKS}). You are done checking for this request: glance at the screenshots, fix anything plainly broken in one edit without checking again, then write your summary.`);
+  } else if (ctx.designChecks >= MAX_CHECKS) {
+    lines.push('', `That was the last check for this request (${ctx.designChecks} of ${MAX_CHECKS}). Fix the FAILs in one edit, then write your summary and say which ones you fixed.`);
+  } else {
+    lines.push('', `Check ${ctx.designChecks} of ${MAX_CHECKS}. Fix all the FAILs in one or two edits, then check once more.`);
+  }
+  // The rules' fixes name the skill's terminal scripts; here, pictures come from the tools.
+  const output = lines.join('\n')
+    .replace(/scripts\/assets\.mjs(?: --video)?/g, 'image_search (then fetch_image into assets/)')
+    .replace(/ ?\(SKILL\.md step \d+[^)]*\)/g, '');
+  return {
+    ok: true,
+    output: output.slice(0, 20000),
+    meta: { label: `${kind}${fails.length ? `, ${fails.length} to fix` : ', clean'}`, count: fails.length, ...(images.length ? { imageDataUrls: images } : {}) },
+  };
+}

package/lib/diagnostics.js

@@ -1,192 +1,192 @@
-/**
- * Quick syntax checks on a file the agent just wrote or edited, so a broken
- * change is reported in the same step instead of surfacing three steps later
- * (or never). Syntax only, and fast: nothing here type-checks a whole project
- * or needs a language server. Idea from opencode, which appends LSP errors to
- * edit results.
- *
- * checkFile() never throws; when a checker is missing or unsure it stays quiet.
- */
-const fs = require('fs');
-const path = require('path');
-const { execFile } = require('child_process');
-
-const TIMEOUT_MS = 8000;
-const MAX_PROBLEMS = 10;
-
-function run(cmd, args, opts = {}) {
-  return new Promise((resolve) => {
-    execFile(cmd, args, { timeout: TIMEOUT_MS, windowsHide: true, maxBuffer: 1024 * 1024, ...opts }, (err, stdout, stderr) => {
-      resolve({ code: err ? (typeof err.code === 'number' ? err.code : 1) : 0, out: `${stdout || ''}${stderr || ''}`, missing: err && err.code === 'ENOENT' });
-    });
-  });
-}
-
-// ── JavaScript ──
-async function checkJs(file) {
-  const r = await run(process.execPath, ['--check', file], { env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' } });
-  if (r.code === 0) return [];
-  const text = r.out.trim();
-  // JSX in a .js file (common in React projects) is not plain JS; node can't judge it.
-  if (/Unexpected token '<'|Unexpected token <|JSX/.test(text)) return [];
-  const loc = text.match(/:(\d+)\r?\n/);
-  const msg = (text.match(/^(SyntaxError: .+)$/m) || [null, text.split('\n').find((l) => l.trim()) || 'syntax error'])[1];
-  return [`${loc ? `line ${loc[1]}: ` : ''}${msg}`];
-}
-
-// ── JSON ──
-const JSONC_NAMES = /^(tsconfig.*|jsconfig.*|\.eslintrc|devcontainer|settings|launch|tasks|extensions)\.json$/i;
-function checkJson(file, text) {
-  if (JSONC_NAMES.test(path.basename(file)) || /[\\/]\.vscode[\\/]/.test(file)) return [];
-  try { JSON.parse(text.replace(/^\uFEFF/, '')); return []; }
-  catch (e) {
-    const pos = Number((e.message.match(/position (\d+)/) || [])[1]);
-    const line = Number.isFinite(pos) ? text.slice(0, pos).split('\n').length : null;
-    return [`${line ? `line ${line}: ` : ''}invalid JSON (${e.message.replace(/ in JSON at position \d+.*$/, '')})`];
-  }
-}
-
-// ── TypeScript / TSX, through the project's own compiler, syntax only ──
-function findUp(start, rel, stop) {
-  let dir = start;
-  while (true) {
-    const p = path.join(dir, rel);
-    if (fs.existsSync(p)) return p;
-    const up = path.dirname(dir);
-    if (up === dir || (stop && dir === stop)) return null;
-    dir = up;
-  }
-}
-// ── Real type checking (semantic), in a warm worker per project ──
-const { fork } = require('child_process');
-const workers = new Map(); // project root -> { proc, pending, nextId, ready }
-const FIRST_CHECK_MS = 25000; // a big project's first build can take a while
-const CHECK_MS = 10000;
-
-function typeWorker(projectRoot, tsDir) {
-  let w = workers.get(projectRoot);
-  if (w && !w.dead) return w;
-  const proc = fork(path.join(__dirname, 'typecheck-worker.js'), [projectRoot, tsDir], {
-    env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
-    stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
-    windowsHide: true,
-  });
-  w = { proc, pending: new Map(), nextId: 1, checks: 0, dead: false };
-  proc.on('message', (m) => {
-    const p = m && m.id != null && w.pending.get(m.id);
-    if (p) { w.pending.delete(m.id); p(m); }
-  });
-  proc.on('exit', () => { w.dead = true; for (const [, p] of w.pending) p({ error: 'worker exited' }); w.pending.clear(); });
-  proc.unref();
-  workers.set(projectRoot, w);
-  return w;
-}
-
-function typeCheck(file, projectRoot, tsDir) {
-  const w = typeWorker(projectRoot, tsDir);
-  const timeout = w.checks++ === 0 ? FIRST_CHECK_MS : CHECK_MS;
-  return new Promise((resolve) => {
-    const id = w.nextId++;
-    const timer = setTimeout(() => { w.pending.delete(id); resolve(null); }, timeout);
-    w.pending.set(id, (m) => { clearTimeout(timer); resolve(m.error ? null : m.problems); });
-    try { w.proc.send({ id, file }); } catch { clearTimeout(timer); resolve(null); }
-  });
-}
-process.on('exit', () => { for (const [, w] of workers) try { w.proc.kill(); } catch {} });
-
-/**
- * Code navigation through the project's own TypeScript (works for .ts, .tsx, .js, .jsx).
- * @param {{op:'definition'|'references'|'implementation'|'hover'|'documentSymbol'|'workspaceSymbol', file?:string, line?:number, character?:number, symbol?:string, query?:string}} req
- * @returns {Promise<{ok:boolean, text:string}>}
- */
-async function navigate(req, cwd) {
-  const start = req.file ? path.dirname(req.file) : cwd;
-  const tsDir = findUp(start, path.join('node_modules', 'typescript'), path.parse(cwd).root);
-  if (!tsDir) return { ok: false, text: 'Code navigation needs TypeScript installed in the project (run npm install typescript). Use search instead.' };
-  const cfg = findUp(start, 'tsconfig.json', path.parse(cwd).root) || findUp(start, 'jsconfig.json', path.parse(cwd).root);
-  const projectRoot = cfg ? path.dirname(cfg) : cwd;
-  const w = typeWorker(projectRoot, tsDir);
-  const timeout = w.checks++ === 0 ? FIRST_CHECK_MS : CHECK_MS;
-  return new Promise((resolve) => {
-    const id = w.nextId++;
-    const timer = setTimeout(() => { w.pending.delete(id); resolve({ ok: false, text: 'Code navigation timed out (the project is still loading). Try again, or use search.' }); }, timeout + 10000);
-    w.pending.set(id, (m) => { clearTimeout(timer); resolve(m.error ? { ok: false, text: `Code navigation failed: ${m.error}` } : { ok: true, text: m.text }); });
-    try { w.proc.send({ id, ...req }); } catch { clearTimeout(timer); resolve({ ok: false, text: 'Code navigation is unavailable.' }); }
-  });
-}
-
-async function checkTs(file, text, cwd) {
-  const tsDir = findUp(path.dirname(file), path.join('node_modules', 'typescript'), path.parse(cwd).root);
-  if (!tsDir) return [];
-  // With a tsconfig/jsconfig the project is set up for type checking: ask
-  // the worker for real (semantic) errors. It falls back to the syntax-only
-  // pass below when it's slow or unavailable.
-  const cfg = findUp(path.dirname(file), 'tsconfig.json', path.parse(cwd).root) || findUp(path.dirname(file), 'jsconfig.json', path.parse(cwd).root);
-  if (cfg) {
-    const problems = await typeCheck(file, path.dirname(cfg), tsDir);
-    if (problems) return problems;
-  }
-  let ts;
-  try { ts = require(tsDir); } catch { return []; }
-  const out = ts.transpileModule(text, {
-    fileName: file,
-    reportDiagnostics: true,
-    compilerOptions: { jsx: file.endsWith('x') ? ts.JsxEmit.Preserve : undefined, target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext },
-  });
-  return (out.diagnostics || []).filter((d) => d.category === ts.DiagnosticCategory.Error).map((d) => {
-    const line = d.file && d.start != null ? d.file.getLineAndCharacterOfPosition(d.start).line + 1 : null;
-    return `${line ? `line ${line}: ` : ''}${ts.flattenDiagnosticMessageText(d.messageText, ' ')}`;
-  });
-}
-
-// ── CSS: unbalanced braces are the classic broken-edit symptom ──
-function checkCss(text) {
-  const clean = text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/g, '""');
-  let depth = 0, line = 1;
-  for (const ch of clean) {
-    if (ch === '\n') line++;
-    else if (ch === '{') depth++;
-    else if (ch === '}' && --depth < 0) return [`line ${line}: a "}" with no matching "{"`];
-  }
-  return depth > 0 ? [`${depth} "{" never closed (end of file)`] : [];
-}
-
-// ── Python ──
-let pythonCmd; // undefined = not probed yet, null = none found
-async function checkPy(file) {
-  if (pythonCmd === undefined) {
-    pythonCmd = null;
-    for (const c of process.platform === 'win32' ? ['py', 'python', 'python3'] : ['python3', 'python']) {
-      const r = await run(c, ['--version']);
-      if (r.code === 0 && /Python 3/.test(r.out)) { pythonCmd = c; break; }
-    }
-  }
-  if (!pythonCmd) return [];
-  const code = 'import sys,ast\nsrc=open(sys.argv[1],encoding="utf-8").read()\ntry:\n ast.parse(src)\nexcept SyntaxError as e:\n print(f"line {e.lineno}: SyntaxError: {e.msg}");sys.exit(1)';
-  const r = await run(pythonCmd, ['-c', code, file]);
-  return r.code === 0 ? [] : [r.out.trim().split('\n').pop()];
-}
-
-/**
- * @param {string} abs  absolute path of the file that just changed
- * @param {string} cwd  project root
- * @returns {Promise<string[]>} problems, empty when clean or not checkable
- */
-async function checkFile(abs, cwd) {
-  try {
-    const ext = path.extname(abs).toLowerCase();
-    if (!['.js', '.cjs', '.mjs', '.json', '.ts', '.tsx', '.mts', '.cts', '.jsx', '.css', '.py'].includes(ext)) return [];
-    const stat = fs.statSync(abs);
-    if (stat.size > 2_000_000) return [];
-    const text = fs.readFileSync(abs, 'utf8');
-    let problems = [];
-    if (ext === '.js' || ext === '.cjs' || ext === '.mjs') problems = await checkJs(abs);
-    else if (ext === '.json') problems = checkJson(abs, text);
-    else if (ext === '.jsx' || ext.startsWith('.ts') || ext === '.mts' || ext === '.cts') problems = await checkTs(abs, text, cwd);
-    else if (ext === '.css') problems = checkCss(text);
-    else if (ext === '.py') problems = await checkPy(abs);
-    return problems.filter(Boolean).slice(0, MAX_PROBLEMS);
-  } catch { return []; }
-}
-
-module.exports = { checkFile, navigate };
+/**
+ * Quick syntax checks on a file the agent just wrote or edited, so a broken
+ * change is reported in the same step instead of surfacing three steps later
+ * (or never). Syntax only, and fast: nothing here type-checks a whole project
+ * or needs a language server. Idea from opencode, which appends LSP errors to
+ * edit results.
+ *
+ * checkFile() never throws; when a checker is missing or unsure it stays quiet.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+
+const TIMEOUT_MS = 8000;
+const MAX_PROBLEMS = 10;
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: TIMEOUT_MS, windowsHide: true, maxBuffer: 1024 * 1024, ...opts }, (err, stdout, stderr) => {
+      resolve({ code: err ? (typeof err.code === 'number' ? err.code : 1) : 0, out: `${stdout || ''}${stderr || ''}`, missing: err && err.code === 'ENOENT' });
+    });
+  });
+}
+
+// ── JavaScript ──
+async function checkJs(file) {
+  const r = await run(process.execPath, ['--check', file], { env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' } });
+  if (r.code === 0) return [];
+  const text = r.out.trim();
+  // JSX in a .js file (common in React projects) is not plain JS; node can't judge it.
+  if (/Unexpected token '<'|Unexpected token <|JSX/.test(text)) return [];
+  const loc = text.match(/:(\d+)\r?\n/);
+  const msg = (text.match(/^(SyntaxError: .+)$/m) || [null, text.split('\n').find((l) => l.trim()) || 'syntax error'])[1];
+  return [`${loc ? `line ${loc[1]}: ` : ''}${msg}`];
+}
+
+// ── JSON ──
+const JSONC_NAMES = /^(tsconfig.*|jsconfig.*|\.eslintrc|devcontainer|settings|launch|tasks|extensions)\.json$/i;
+function checkJson(file, text) {
+  if (JSONC_NAMES.test(path.basename(file)) || /[\\/]\.vscode[\\/]/.test(file)) return [];
+  try { JSON.parse(text.replace(/^\uFEFF/, '')); return []; }
+  catch (e) {
+    const pos = Number((e.message.match(/position (\d+)/) || [])[1]);
+    const line = Number.isFinite(pos) ? text.slice(0, pos).split('\n').length : null;
+    return [`${line ? `line ${line}: ` : ''}invalid JSON (${e.message.replace(/ in JSON at position \d+.*$/, '')})`];
+  }
+}
+
+// ── TypeScript / TSX, through the project's own compiler, syntax only ──
+function findUp(start, rel, stop) {
+  let dir = start;
+  while (true) {
+    const p = path.join(dir, rel);
+    if (fs.existsSync(p)) return p;
+    const up = path.dirname(dir);
+    if (up === dir || (stop && dir === stop)) return null;
+    dir = up;
+  }
+}
+// ── Real type checking (semantic), in a warm worker per project ──
+const { fork } = require('child_process');
+const workers = new Map(); // project root -> { proc, pending, nextId, ready }
+const FIRST_CHECK_MS = 25000; // a big project's first build can take a while
+const CHECK_MS = 10000;
+
+function typeWorker(projectRoot, tsDir) {
+  let w = workers.get(projectRoot);
+  if (w && !w.dead) return w;
+  const proc = fork(path.join(__dirname, 'typecheck-worker.js'), [projectRoot, tsDir], {
+    env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
+    stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+    windowsHide: true,
+  });
+  w = { proc, pending: new Map(), nextId: 1, checks: 0, dead: false };
+  proc.on('message', (m) => {
+    const p = m && m.id != null && w.pending.get(m.id);
+    if (p) { w.pending.delete(m.id); p(m); }
+  });
+  proc.on('exit', () => { w.dead = true; for (const [, p] of w.pending) p({ error: 'worker exited' }); w.pending.clear(); });
+  proc.unref();
+  workers.set(projectRoot, w);
+  return w;
+}
+
+function typeCheck(file, projectRoot, tsDir) {
+  const w = typeWorker(projectRoot, tsDir);
+  const timeout = w.checks++ === 0 ? FIRST_CHECK_MS : CHECK_MS;
+  return new Promise((resolve) => {
+    const id = w.nextId++;
+    const timer = setTimeout(() => { w.pending.delete(id); resolve(null); }, timeout);
+    w.pending.set(id, (m) => { clearTimeout(timer); resolve(m.error ? null : m.problems); });
+    try { w.proc.send({ id, file }); } catch { clearTimeout(timer); resolve(null); }
+  });
+}
+process.on('exit', () => { for (const [, w] of workers) try { w.proc.kill(); } catch {} });
+
+/**
+ * Code navigation through the project's own TypeScript (works for .ts, .tsx, .js, .jsx).
+ * @param {{op:'definition'|'references'|'implementation'|'hover'|'documentSymbol'|'workspaceSymbol', file?:string, line?:number, character?:number, symbol?:string, query?:string}} req
+ * @returns {Promise<{ok:boolean, text:string}>}
+ */
+async function navigate(req, cwd) {
+  const start = req.file ? path.dirname(req.file) : cwd;
+  const tsDir = findUp(start, path.join('node_modules', 'typescript'), path.parse(cwd).root);
+  if (!tsDir) return { ok: false, text: 'Code navigation needs TypeScript installed in the project (run npm install typescript). Use search instead.' };
+  const cfg = findUp(start, 'tsconfig.json', path.parse(cwd).root) || findUp(start, 'jsconfig.json', path.parse(cwd).root);
+  const projectRoot = cfg ? path.dirname(cfg) : cwd;
+  const w = typeWorker(projectRoot, tsDir);
+  const timeout = w.checks++ === 0 ? FIRST_CHECK_MS : CHECK_MS;
+  return new Promise((resolve) => {
+    const id = w.nextId++;
+    const timer = setTimeout(() => { w.pending.delete(id); resolve({ ok: false, text: 'Code navigation timed out (the project is still loading). Try again, or use search.' }); }, timeout + 10000);
+    w.pending.set(id, (m) => { clearTimeout(timer); resolve(m.error ? { ok: false, text: `Code navigation failed: ${m.error}` } : { ok: true, text: m.text }); });
+    try { w.proc.send({ id, ...req }); } catch { clearTimeout(timer); resolve({ ok: false, text: 'Code navigation is unavailable.' }); }
+  });
+}
+
+async function checkTs(file, text, cwd) {
+  const tsDir = findUp(path.dirname(file), path.join('node_modules', 'typescript'), path.parse(cwd).root);
+  if (!tsDir) return [];
+  // With a tsconfig/jsconfig the project is set up for type checking: ask
+  // the worker for real (semantic) errors. It falls back to the syntax-only
+  // pass below when it's slow or unavailable.
+  const cfg = findUp(path.dirname(file), 'tsconfig.json', path.parse(cwd).root) || findUp(path.dirname(file), 'jsconfig.json', path.parse(cwd).root);
+  if (cfg) {
+    const problems = await typeCheck(file, path.dirname(cfg), tsDir);
+    if (problems) return problems;
+  }
+  let ts;
+  try { ts = require(tsDir); } catch { return []; }
+  const out = ts.transpileModule(text, {
+    fileName: file,
+    reportDiagnostics: true,
+    compilerOptions: { jsx: file.endsWith('x') ? ts.JsxEmit.Preserve : undefined, target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext },
+  });
+  return (out.diagnostics || []).filter((d) => d.category === ts.DiagnosticCategory.Error).map((d) => {
+    const line = d.file && d.start != null ? d.file.getLineAndCharacterOfPosition(d.start).line + 1 : null;
+    return `${line ? `line ${line}: ` : ''}${ts.flattenDiagnosticMessageText(d.messageText, ' ')}`;
+  });
+}
+
+// ── CSS: unbalanced braces are the classic broken-edit symptom ──
+function checkCss(text) {
+  const clean = text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/g, '""');
+  let depth = 0, line = 1;
+  for (const ch of clean) {
+    if (ch === '\n') line++;
+    else if (ch === '{') depth++;
+    else if (ch === '}' && --depth < 0) return [`line ${line}: a "}" with no matching "{"`];
+  }
+  return depth > 0 ? [`${depth} "{" never closed (end of file)`] : [];
+}
+
+// ── Python ──
+let pythonCmd; // undefined = not probed yet, null = none found
+async function checkPy(file) {
+  if (pythonCmd === undefined) {
+    pythonCmd = null;
+    for (const c of process.platform === 'win32' ? ['py', 'python', 'python3'] : ['python3', 'python']) {
+      const r = await run(c, ['--version']);
+      if (r.code === 0 && /Python 3/.test(r.out)) { pythonCmd = c; break; }
+    }
+  }
+  if (!pythonCmd) return [];
+  const code = 'import sys,ast\nsrc=open(sys.argv[1],encoding="utf-8").read()\ntry:\n ast.parse(src)\nexcept SyntaxError as e:\n print(f"line {e.lineno}: SyntaxError: {e.msg}");sys.exit(1)';
+  const r = await run(pythonCmd, ['-c', code, file]);
+  return r.code === 0 ? [] : [r.out.trim().split('\n').pop()];
+}
+
+/**
+ * @param {string} abs  absolute path of the file that just changed
+ * @param {string} cwd  project root
+ * @returns {Promise<string[]>} problems, empty when clean or not checkable
+ */
+async function checkFile(abs, cwd) {
+  try {
+    const ext = path.extname(abs).toLowerCase();
+    if (!['.js', '.cjs', '.mjs', '.json', '.ts', '.tsx', '.mts', '.cts', '.jsx', '.css', '.py'].includes(ext)) return [];
+    const stat = fs.statSync(abs);
+    if (stat.size > 2_000_000) return [];
+    const text = fs.readFileSync(abs, 'utf8');
+    let problems = [];
+    if (ext === '.js' || ext === '.cjs' || ext === '.mjs') problems = await checkJs(abs);
+    else if (ext === '.json') problems = checkJson(abs, text);
+    else if (ext === '.jsx' || ext.startsWith('.ts') || ext === '.mts' || ext === '.cts') problems = await checkTs(abs, text, cwd);
+    else if (ext === '.css') problems = checkCss(text);
+    else if (ext === '.py') problems = await checkPy(abs);
+    return problems.filter(Boolean).slice(0, MAX_PROBLEMS);
+  } catch { return []; }
+}
+
+module.exports = { checkFile, navigate };