@jefuriiij/synthra 0.1.10 → 0.1.12

package/CHANGELOG.md

@@ -0,0 +1,122 @@
+# Synthra changelog
+
+Notable changes per version. This file ships inside the npm tarball — `syn .`
+reads it after an auto-update to show you what changed.
+
+For older versions, see [GitHub Releases](https://github.com/jefuriiij/synthra/releases).
+
+---
+
+## [0.1.12] — 2026-05-29
+
+### Fixed
+
+- **`Language.query is deprecated` spam at scan time.** Every parsed file
+  printed the warning — 57 prints on a Flutter codebase, one per parsed
+  file. Switched all four parsers (TypeScript, JavaScript, Python, Dart,
+  plus the generic helper) from the deprecated `language.query(QUERY)`
+  to `new Query(language, QUERY)`. No behavior change, just clean
+  terminal output.
+
+---
+
+## [0.1.11] — 2026-05-29
+
+### Fixed
+
+- **Dart parser actually runs now.** Was silently broken since v0.1 due to an
+  ABI mismatch (shipped wasm was ABI v15, pinned `web-tree-sitter` only
+  supported v13–v14). Every `.dart` file got zero symbols, zero imports —
+  the exception was swallowed by the parser's try/catch. Bumped
+  `web-tree-sitter` to `^0.25.10` to fix.
+- **Real Dart symbol extraction.** Classes, mixins, extensions, enums,
+  typedefs, top-level functions, methods, getters, setters, constructors.
+- **Dart import normalization.** `package:foo/bar.dart` and `dart:async` are
+  stripped (cross-project); bare `'sibling.dart'` is rewritten to
+  `./sibling.dart` so the project resolver can complete them.
+
+### Changed
+
+- **Update check runs on every `syn .`** (no more 24h cache). If you're on
+  latest, stays silent. If outdated, prompts `[y/N]` as before.
+- **Auto-update now shows a changelog.** After `npm install -g …@latest`
+  succeeds, Synthra prints the new version's section from this file before
+  telling you to re-run. Catches `npm install` outside of `syn .` too —
+  next startup compares your current version to `~/.synthra/last-seen-version.json`
+  and prints if it's newer.
+
+---
+
+## [0.1.10] — 2026-05-29
+
+### Changed
+
+- **CLAUDE.md policy v2 → v3.** Session-end now goes through
+  `context_remember({kind: "task"|"decision"|"next"})` instead of writing
+  `.synthra/CONTEXT.md` directly. The Stop hook always re-rendered CONTEXT.md
+  from `context-store.json` — under v2 Claude's direct writes were getting
+  wiped on session end. Existing v2 blocks auto-upgrade.
+
+### Added
+
+- **Scanner ignores more build caches.** `.dart_tool/`, `.flutter-plugins`,
+  `.flutter-plugins-dependencies`, `.gradle/`, `target/`, `Pods/`,
+  `DerivedData/`, `__pycache__/`, `.venv/`, `venv/`, `.tox/`,
+  `.pytest_cache/`, `.mypy_cache/`, `.ruff_cache/`, `obj/`, `.vs/`.
+
+---
+
+## [0.1.9] — 2026-05-29
+
+### Fixed
+
+- **Crash on prototype-colliding symbol names.** `buildSymbolIndex` built
+  the lookup on a plain `{}`, so a symbol named `toString` (which every
+  Dart class overrides), `constructor`, `valueOf`, etc. resolved to the
+  inherited `Object.prototype` member and crashed on `.push`. Now uses
+  `Object.create(null)` on both fresh-build and load-from-disk paths.
+
+---
+
+## [0.1.8] — 2026-05-29
+
+### Added
+
+- **Interactive auto-update.** `syn .` checks npm at startup; if a newer
+  version is available, prompts `[y/N]`. On `y`, runs
+  `npm install -g @jefuriiij/synthra@latest` with stdio inherited and
+  exits with re-run instructions. Non-TTY runs (CI, piped stdin) fall
+  back to a silent one-line hint. `SYN_NO_UPDATE_CHECK=1` opts out.
+
+---
+
+## [0.1.7] — 2026-05-29
+
+### Fixed
+
+- **JS parser missed CommonJS imports + JS class names.** Unified TS/JS
+  query only matched ES `import_statement`, and used `(type_identifier)`
+  for class names — which is TS-grammar-only. Result: every `.js`/`.cjs`/
+  `.mjs` file silently produced zero imports, and any class in a JS file
+  was skipped. Split into `TS_QUERY` and `JS_QUERY`; JS query adds a
+  `require()` capture and uses `(identifier)` for class names.
+
+---
+
+## [0.1.6] — 2026-05-29
+
+### Fixed
+
+- **MCP registration now uses `--scope project`** so the Claude Code IDE
+  extension actually sees Synthra. The previous `--scope local` wrote to
+  a per-project section of `~/.claude.json` that only the `claude` CLI
+  reads — invisible to the IDE.
+
+---
+
+## [0.1.5] and earlier
+
+See [GitHub commits](https://github.com/jefuriiij/synthra/commits/main) for
+detail. v0.1.5 introduced the v2 policy template with namespace + skip rules;
+v0.1.4 fixed a DEP0190 deprecation on Windows; v0.1.3 was the dashboard
+redesign (Cool Marine palette, FAQ modal, savings audit row).

package/README.md

@@ -177,13 +177,15 @@ Claude Code honors the block and pivots to the MCP tool. The structured pack is
 
 ## Self-update
 
-Daily fire-and-forget version check against the npm registry. When a newer version is available:
+Every `syn .` checks the npm registry for a newer version (no cache — always fresh; 2s hard timeout; silent fallthrough on network failure). When you're on latest, the check stays silent and `syn .` proceeds. When you're outdated:
 
 - **Interactive shell** (TTY) → you see `[syn] Synthra X.Y.Z is available (you have A.B.C). Update now? [y/N]:` *before* the scan starts. Type `y` to install; press Enter (or anything else) to skip and continue with the current version.
-- **Non-interactive** (CI, piped stdin) → silent one-line log line, no prompt. Pure fire-and-forget.
+- **Non-interactive** (CI, piped stdin) → silent one-line hint, no prompt.
 - **Disabled entirely** → set `SYN_NO_UPDATE_CHECK=1`.
 
-On `y`, Synthra spawns `npm install -g @jefuriiij/synthra@latest` with stdio inherited (you see npm's progress), then exits with re-run instructions — the running Node process is still the old version and can't hot-swap its own code mid-run. Cached at `~/.synthra/version-check.json` for 24h so you're never nagged on rapid `syn .` runs.
+On `y`, Synthra spawns `npm install -g @jefuriiij/synthra@latest` with stdio inherited (you see npm's progress), then **prints the new version's `CHANGELOG.md` section** (so you know what you just got), then exits with re-run instructions — the running Node process is still the old version and can't hot-swap its own code mid-run.
+
+If you upgrade via `npm install -g @jefuriiij/synthra@latest` directly (outside Synthra's prompt), the next `syn .` notices and prints the changelog anyway. It tracks the last-seen version at `~/.synthra/last-seen-version.json`.
 
 ---
 

package/dist/cli/index.js

@@ -18,7 +18,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jefuriiij/synthra",
-      version: "0.1.10",
+      version: "0.1.12",
       publishConfig: {
         access: "public"
       },
@@ -39,6 +39,7 @@ var init_package = __esm({
         "dist",
         "bin",
         "README.md",
+        "CHANGELOG.md",
         "LICENSE",
         "ROADMAP.md"
       ],
@@ -71,7 +72,7 @@ var init_package = __esm({
         ignore: "^7.0.0",
         sade: "^1.8.1",
         "tree-sitter-wasms": "^0.1.12",
-        "web-tree-sitter": "~0.22.6"
+        "web-tree-sitter": "^0.25.10"
       },
       devDependencies: {
         "@types/cross-spawn": "^6.0.6",
@@ -2103,7 +2104,7 @@ function extractKeywords(content, _ext) {
 }
 
 // src/scanner/extract.ts
-var RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".svelte", ".vue"];
+var RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".svelte", ".vue", ".dart"];
 var INDEX_FILES = ["index.ts", "index.tsx", "index.js", "index.jsx", "__init__.py"];
 function fileId(relPath) {
   return `file:${relPath}`;
@@ -2243,9 +2244,10 @@ function buildSymbolIndex(graph) {
 // src/scanner/parser.ts
 import { readFile as readFile6 } from "fs/promises";
 import { createRequire } from "module";
-import Parser from "web-tree-sitter";
+import { Language, Parser } from "web-tree-sitter";
 
 // src/scanner/parsers/_generic.ts
+import { Query } from "web-tree-sitter";
 function firstLine(text, max = 200) {
   const line = text.split(/\r?\n/, 1)[0] ?? "";
   return line.length > max ? line.slice(0, max) + "\u2026" : line;
@@ -2260,7 +2262,7 @@ async function runGenericParser(config, f, source) {
     const { parser, language } = await createParser(config.grammar);
     const tree = parser.parse(source);
     if (!tree) return { file: f, source, symbols, imports, calls: [] };
-    const query = language.query(config.query);
+    const query = new Query(language, config.query);
     const matches = query.matches(tree.rootNode);
     for (const match of matches) {
       const byName = /* @__PURE__ */ new Map();
@@ -2391,27 +2393,95 @@ async function parseCSharp(f, source) {
 }
 
 // src/scanner/parsers/dart.ts
+import { Query as Query2 } from "web-tree-sitter";
 var QUERY4 = `
-(class_definition (identifier) @class.name) @class
-(mixin_declaration (identifier) @class.name) @mixin
-(extension_declaration (identifier) @class.name) @ext
-(function_signature (identifier) @function.name) @function
+(class_definition name: (identifier) @class.name) @class
+(mixin_declaration (identifier) @mixin.name) @mixin
+(extension_declaration name: (identifier) @ext.name) @ext
+(enum_declaration name: (identifier) @enum.name) @enum
+(type_alias (type_identifier) @typedef.name) @typedef
+
+(program (function_signature name: (identifier) @function.name) @function)
+
+(method_signature (function_signature name: (identifier) @method.name)) @method
+(method_signature (getter_signature name: (identifier) @getter.name)) @getter
+(method_signature (setter_signature name: (identifier) @setter.name)) @setter
+(constructor_signature name: (identifier) @ctor.name) @ctor
+
+(import_or_export (library_import (import_specification (configurable_uri (uri (string_literal) @import)))))
 `;
+var DECLS = [
+  { declCap: "class", nameCap: "class.name", kind: "class" },
+  { declCap: "mixin", nameCap: "mixin.name", kind: "class" },
+  { declCap: "ext", nameCap: "ext.name", kind: "class" },
+  { declCap: "enum", nameCap: "enum.name", kind: "enum" },
+  { declCap: "typedef", nameCap: "typedef.name", kind: "type" },
+  { declCap: "function", nameCap: "function.name", kind: "function" },
+  { declCap: "method", nameCap: "method.name", kind: "method" },
+  { declCap: "getter", nameCap: "getter.name", kind: "method" },
+  { declCap: "setter", nameCap: "setter.name", kind: "method" },
+  { declCap: "ctor", nameCap: "ctor.name", kind: "method" }
+];
+function firstLine2(text, max = 200) {
+  const line = text.split(/\r?\n/, 1)[0] ?? "";
+  return line.length > max ? line.slice(0, max) + "\u2026" : line;
+}
+function normalizeDartImport(raw) {
+  const stripped = raw.replace(/^['"]|['"]$/g, "");
+  if (!stripped) return null;
+  if (stripped.startsWith("package:")) return null;
+  if (stripped.startsWith("dart:")) return null;
+  if (stripped.startsWith(".") || stripped.startsWith("/")) return stripped;
+  return `./${stripped}`;
+}
 async function parseDart(f, source) {
-  return runGenericParser(
-    {
-      grammar: "dart",
-      query: QUERY4,
-      decls: [
-        { declCapture: "class", nameCapture: "class.name", kind: "class" },
-        { declCapture: "mixin", nameCapture: "class.name", kind: "class" },
-        { declCapture: "ext", nameCapture: "class.name", kind: "class" },
-        { declCapture: "function", nameCapture: "function.name", kind: "function" }
-      ]
-    },
-    f,
-    source
-  );
+  let symbols = [];
+  let imports = [];
+  try {
+    const { parser, language } = await createParser("dart");
+    const tree = parser.parse(source);
+    if (!tree) return { file: f, source, symbols, imports, calls: [] };
+    const query = new Query2(language, QUERY4);
+    const matches = query.matches(tree.rootNode);
+    for (const match of matches) {
+      const byName = /* @__PURE__ */ new Map();
+      for (const cap of match.captures) byName.set(cap.name, cap.node);
+      let matched = null;
+      for (const d of DECLS) {
+        if (byName.has(d.declCap) && byName.has(d.nameCap)) {
+          matched = d;
+          break;
+        }
+      }
+      if (matched) {
+        const declNode = byName.get(matched.declCap);
+        const nameNode = byName.get(matched.nameCap);
+        symbols.push({
+          name: nameNode.text,
+          kind: matched.kind,
+          startLine: declNode.startPosition.row + 1,
+          endLine: declNode.endPosition.row + 1,
+          signature: firstLine2(declNode.text)
+        });
+        continue;
+      }
+      const importNode = byName.get("import");
+      if (importNode) {
+        const norm = normalizeDartImport(importNode.text);
+        if (norm) imports.push(norm);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    symbols = symbols.filter((s) => {
+      const k = `${s.name}:${s.startLine}`;
+      if (seen.has(k)) return false;
+      seen.add(k);
+      return true;
+    });
+    imports = Array.from(new Set(imports));
+  } catch {
+  }
+  return { file: f, source, symbols, imports, calls: [] };
 }
 
 // src/scanner/parsers/go.ts
@@ -2515,6 +2585,7 @@ async function parsePhp(f, source) {
 }
 
 // src/scanner/parsers/python.ts
+import { Query as Query3 } from "web-tree-sitter";
 var QUERY9 = `
 (function_definition name: (identifier) @function.name) @function
 (class_definition name: (identifier) @class.name) @class
@@ -2522,7 +2593,7 @@ var QUERY9 = `
 (import_from_statement module_name: (dotted_name) @import.from)
 (import_from_statement module_name: (relative_import) @import.from)
 `;
-function firstLine2(text, max = 200) {
+function firstLine3(text, max = 200) {
   const line = text.split(/\r?\n/, 1)[0] ?? "";
   return line.length > max ? line.slice(0, max) + "\u2026" : line;
 }
@@ -2533,7 +2604,7 @@ async function parsePython(f, source) {
     const { parser, language } = await createParser("python");
     const tree = parser.parse(source);
     if (!tree) return { file: f, source, symbols, imports, calls: [] };
-    const query = language.query(QUERY9);
+    const query = new Query3(language, QUERY9);
     const matches = query.matches(tree.rootNode);
     for (const match of matches) {
       const byName = /* @__PURE__ */ new Map();
@@ -2548,7 +2619,7 @@ async function parsePython(f, source) {
           kind: isMethod ? "method" : "function",
           startLine: funcDecl.startPosition.row + 1,
           endLine: funcDecl.endPosition.row + 1,
-          signature: firstLine2(funcDecl.text)
+          signature: firstLine3(funcDecl.text)
         });
         continue;
       }
@@ -2560,7 +2631,7 @@ async function parsePython(f, source) {
           kind: "class",
           startLine: classDecl.startPosition.row + 1,
           endLine: classDecl.endPosition.row + 1,
-          signature: firstLine2(classDecl.text)
+          signature: firstLine3(classDecl.text)
         });
         continue;
       }
@@ -2631,6 +2702,7 @@ async function parseRust(f, source) {
 }
 
 // src/scanner/parsers/typescript.ts
+import { Query as Query4 } from "web-tree-sitter";
 var TS_QUERY = `
 (function_declaration name: (identifier) @function.name) @function
 (class_declaration name: (type_identifier) @class.name) @class
@@ -2660,7 +2732,7 @@ function queryFor(grammar) {
 function unquote(s) {
   return s.replace(/^["'`]|["'`]$/g, "");
 }
-function firstLine3(text, max = 200) {
+function firstLine4(text, max = 200) {
   const line = text.split(/\r?\n/, 1)[0] ?? "";
   return line.length > max ? line.slice(0, max) + "\u2026" : line;
 }
@@ -2680,7 +2752,7 @@ async function parseTypeScript(f, source) {
     const { parser, language } = await createParser(grammar);
     const tree = parser.parse(source);
     if (!tree) return { file: f, source, symbols, imports, calls: [] };
-    const query = language.query(queryFor(grammar));
+    const query = new Query4(language, queryFor(grammar));
     const matches = query.matches(tree.rootNode);
     for (const match of matches) {
       const byName = /* @__PURE__ */ new Map();
@@ -2692,7 +2764,7 @@ async function parseTypeScript(f, source) {
           kind: shape.kind,
           startLine: shape.decl.startPosition.row + 1,
           endLine: shape.decl.endPosition.row + 1,
-          signature: firstLine3(shape.decl.text)
+          signature: firstLine4(shape.decl.text)
         });
         continue;
       }
@@ -2837,7 +2909,7 @@ async function loadGrammar(name) {
   const cached = languageCache.get(name);
   if (cached) return cached;
   const wasmPath = require2.resolve(GRAMMAR_FILES[name]);
-  const lang = await Parser.Language.load(wasmPath);
+  const lang = await Language.load(wasmPath);
   languageCache.set(name, lang);
   return lang;
 }
@@ -4712,9 +4784,8 @@ import { join as join10 } from "path";
 import { createInterface } from "readline/promises";
 import spawn from "cross-spawn";
 var PKG_NAME = "@jefuriiij/synthra";
-var CACHE_DIR = join10(homedir3(), ".synthra");
-var CACHE_PATH = join10(CACHE_DIR, "version-check.json");
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var SYNTHRA_DIR = join10(homedir3(), ".synthra");
+var LAST_SEEN_PATH = join10(SYNTHRA_DIR, "last-seen-version.json");
 var REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PKG_NAME)}/latest`;
 var FETCH_TIMEOUT_MS = 2e3;
 var currentVersionCache = null;
@@ -4729,23 +4800,6 @@ async function getCurrentVersion() {
     return "0.0.0";
   }
 }
-async function readCache() {
-  try {
-    const raw = await readFile14(CACHE_PATH, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.checked_at || !parsed.latest_version) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function writeCache(cache) {
-  try {
-    await mkdir10(CACHE_DIR, { recursive: true });
-    await writeFile9(CACHE_PATH, JSON.stringify(cache, null, 2), "utf8");
-  } catch {
-  }
-}
 function isNewer(candidate, baseline) {
   const a = candidate.split(/[.-]/).map((p) => Number(p));
   const b = baseline.split(/[.-]/).map((p) => Number(p));
@@ -4776,23 +4830,88 @@ async function checkForUpdate() {
   if (process.env.SYN_NO_UPDATE_CHECK === "1") {
     return { current, latest: null, hasUpdate: false };
   }
-  const cache = await readCache();
-  const now = Date.now();
-  const cacheAge = cache ? now - Date.parse(cache.checked_at) : Infinity;
-  let latest = null;
-  if (cache && cacheAge < CACHE_TTL_MS) {
-    latest = cache.latest_version;
-  } else {
-    latest = await fetchLatestFromRegistry();
-    if (latest) {
-      await writeCache({ checked_at: (/* @__PURE__ */ new Date()).toISOString(), latest_version: latest });
-    } else if (cache) {
-      latest = cache.latest_version;
-    }
-  }
+  const latest = await fetchLatestFromRegistry();
   const hasUpdate = latest ? isNewer(latest, current) : false;
   return { current, latest, hasUpdate };
 }
+async function readLastSeen() {
+  try {
+    const raw = await readFile14(LAST_SEEN_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function writeLastSeen(version) {
+  try {
+    await mkdir10(SYNTHRA_DIR, { recursive: true });
+    const data = { version, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+    await writeFile9(LAST_SEEN_PATH, JSON.stringify(data, null, 2), "utf8");
+  } catch {
+  }
+}
+function npmGlobalRoot() {
+  return new Promise((resolve5) => {
+    const chunks = [];
+    const proc = spawn("npm", ["root", "-g"], { stdio: ["ignore", "pipe", "ignore"] });
+    proc.stdout?.on("data", (c) => chunks.push(c));
+    proc.on("error", () => resolve5(null));
+    proc.on("exit", (code) => {
+      if (code !== 0) return resolve5(null);
+      const out = Buffer.concat(chunks).toString("utf8").trim();
+      resolve5(out || null);
+    });
+  });
+}
+function extractChangelogSection(text, version) {
+  const escapedVersion = version.replace(/\./g, "\\.");
+  const headingRe = new RegExp(`^##\\s+\\[?v?${escapedVersion}\\]?.*$`, "m");
+  const m = headingRe.exec(text);
+  if (!m) return null;
+  const startBody = m.index + m[0].length;
+  const rest = text.slice(startBody);
+  const nextHeadingIdx = rest.search(/^##\s+/m);
+  const body = nextHeadingIdx < 0 ? rest : rest.slice(0, nextHeadingIdx);
+  return body.replace(/^---\s*$/gm, "").trim() || null;
+}
+async function readInstalledChangelog() {
+  const root = await npmGlobalRoot();
+  if (!root) return null;
+  try {
+    return await readFile14(join10(root, "@jefuriiij", "synthra", "CHANGELOG.md"), "utf8");
+  } catch {
+    return null;
+  }
+}
+async function printChangelogForVersion(version) {
+  const md = await readInstalledChangelog();
+  if (!md) return;
+  const section = extractChangelogSection(md, version);
+  if (!section) return;
+  log.info("");
+  log.info(`What's new in ${version}:`);
+  log.info("");
+  for (const line of section.split(/\r?\n/)) {
+    log.info(`  ${line}`);
+  }
+  log.info("");
+}
+async function runStartupChangelogCheck() {
+  try {
+    const current = await getCurrentVersion();
+    const lastSeen = await readLastSeen();
+    if (!lastSeen) {
+      await writeLastSeen(current);
+      return;
+    }
+    if (isNewer(current, lastSeen)) {
+      await printChangelogForVersion(current);
+      await writeLastSeen(current);
+    }
+  } catch {
+  }
+}
 async function promptYesNo(question) {
   if (!process.stdin.isTTY) return false;
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -4834,7 +4953,10 @@ async function promptForUpdateOrLog() {
       log.warn("npm install failed \u2014 continuing with current version.");
       return;
     }
-    log.info(`\u2713 Updated to ${r.latest}. Please re-run: syn .`);
+    log.info(`\u2713 Updated to ${r.latest}.`);
+    await printChangelogForVersion(r.latest);
+    await writeLastSeen(r.latest);
+    log.info(`Please re-run: syn .`);
     process.exit(0);
   } catch {
   }
@@ -4955,6 +5077,7 @@ async function defaultFlow(rawPath, opts) {
   const projectRoot = resolve4(rawPath);
   const paths = resolvePaths(projectRoot);
   const cfg = loadConfig();
+  await runStartupChangelogCheck();
   await promptForUpdateOrLog();
   await recordProject(projectRoot);
   const scan = await scanCommand(rawPath);