aihand 0.0.1 → 0.1.0

package/dist/chunk-C7DGE6MY.cjs

@@ -0,0 +1,1456 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunk3X4FTHLCcjs = require('./chunk-3X4FTHLC.cjs');
+
+
+
+
+var _chunkDUUCVLC3cjs = require('./chunk-DUUCVLC3.cjs');
+
+// src/read/inject.ts
+var _fs = require('fs');
+var _path = require('path');
+var START_TAG = "<!-- AIDEV:START -->";
+var END_TAG = "<!-- AIDEV:END -->";
+function ensureMarkers(filePath) {
+  if (!_fs.existsSync.call(void 0, filePath)) {
+    const dir = _path.dirname.call(void 0, filePath);
+    if (!_fs.existsSync.call(void 0, dir))
+      _fs.mkdirSync.call(void 0, dir, { recursive: true });
+    _fs.writeFileSync.call(void 0, filePath, `${START_TAG}
+${END_TAG}
+`);
+    return "created";
+  }
+  const content = _fs.readFileSync.call(void 0, filePath, "utf-8");
+  if (content.includes(START_TAG))
+    return "skipped";
+  const sep = content.endsWith("\n") ? "" : "\n";
+  _fs.writeFileSync.call(void 0, filePath, `${content}${sep}
+${START_TAG}
+${END_TAG}
+`);
+  return "marked";
+}
+var DEV_TOOL_HINT = "> Before changing code: `aihand` is this repo's read\xB7ui\xB7refactor tool (read the control panel / reverse-locate, drive the running page, AST refactor). Run `aihand --help` to expand.";
+var CODEMAP_HINT = [
+  "> **Locate code** (on demand, don't pull the whole map first):",
+  "> \xB7 change a UI behavior \u2192 `aihand read panel` (knob \xD7 store morphism: one line per control, which field it writes)",
+  "> \xB7 where files live / the layout \u2192 `aihand read tree`",
+  "> \xB7 runtime coord \u2192 static symbol \u2192 `aihand read source <file:line>` (with callers/callees)",
+  "> \xB7 the full map at once \u2192 `aihand read --stdout`"
+].join("\n");
+var DEFAULT_INJECT_FILES = ["CLAUDE.md", "AGENTS.md"];
+function renderSections(config, data) {
+  const sections = [];
+  if (data.overview)
+    sections.push(`# Overview
+
+${data.overview}`);
+  if (config.read.injectCodemap) {
+    if (data.panel)
+      sections.push(`# Control Panel \u2014 \u7CFB\u7EDF\u7684\u63A7\u5236\u8BBA\u6A21\u578B
+
+\u8FD9\u662F\u6700\u9AD8\u62BD\u8C61\u5C42\uFF1A\u4E00\u4E2A\u6D17\u8863\u673A\u9762\u677F\u3002\u7CFB\u7EDF\u65E0\u8BBA\u5185\u90E8\u591A\u590D\u6742\uFF08\u51E0\u5343\u7EC4\u4EF6\uFF09\uFF0C\u5176\u672C\u8D28 = **(\u65CB\u94AE \xD7 \u72B6\u6001) \u2192 \u72B6\u6001\u8F6C\u79FB**\u3002\u65CB\u94AE\u662F\u5B8C\u6574\u63A5\u53E3\uFF0C\u62E8\u4EFB\u4E00\u65CB\u94AE\u6574\u4E2A App \u8FDB\u5165\u65B0\u72B6\u6001\uFF1B\u4E0B\u9762\u7684\u72B6\u6001\u663E\u793A\u662F\u8F93\u51FA\u7AEF/\u53EF\u89C2\u6D4B\u91CF\u3002\u4E0B\u9762\u7684\u51E0\u5343\u7EC4\u4EF6\u5168\u662F\u8FD9\u5341\u51E0\u4E2A\u63A7\u5236\u91CF\u7684\u5C55\u5F00\u3002\u8BFB\u5B83\u5373\u77E5"\u8FD9 App \u80FD\u5E72\u4EC0\u4E48\u3001\u7531\u54EA\u4E9B\u72B6\u6001\u9A71\u52A8\u3001\u6539\u67D0\u4E2A UI \u53BB\u54EA\u4E2A store \u5B57\u6BB5"\u3002\u6539 UI \u884C\u4E3A\u524D\u5148\u5728\u8FD9\u91CC\u5B9A\u4F4D\uFF0C\u518D \`aihand read source\` \u5C55\u5F00\u3002
+
+## \u65CB\u94AE\uFF08\u8F93\u5165\u7AEF\uFF09
+
+\u4E00\u884C\u4E00\u4E2A\u65CB\u94AE\uFF1A\`\u300C\u540D\u5B57\u300D \u4E8B\u4EF6 \u2192 store.{ \u5B57\u6BB5=\u76EE\u6807\u503C }  :\u884C\u53F7\`\u2014\u2014\u62E8\u5B83\u628A\u54EA\u4E2A store \u72B6\u6001\u63A8\u5411\u4EC0\u4E48\u503C\u3002
+
+\`\`\`
+${data.panel}
+\`\`\``);
+    if (data.state)
+      sections.push(`## \u72B6\u6001\u663E\u793A\uFF08\u8F93\u51FA\u7AEF / \u53EF\u89C2\u6D4B\u91CF\uFF09
+
+\u7CFB\u7EDF\u7531\u54EA\u4E9B\u72B6\u6001\u91CF\u6784\u6210\u3001\u5404\u81EA\u521D\u503C\u3001\u5404\u81EA\u503C\u57DF\uFF08\`{a|b|c}\` = \u53EF\u679A\u4E3E\u7684\u79BB\u6563\u6001\uFF0C\u5373\u9762\u677F\u80FD\u663E\u793A\u7684\u72B6\u6001\u673A\uFF1B\u65E0\u6807\u6CE8 = boolean/\u5BF9\u8C61\u7B49\u975E\u679A\u4E3E\u6001\uFF09\u3002\u65CB\u94AE\u62E8\u52A8\u7684\u5C31\u662F\u8FD9\u4E9B\u91CF\u3002
+
+\`\`\`
+${data.state}
+\`\`\``);
+    if (data.tree)
+      sections.push(`# File Tree
+
+${data.tree}`);
+    if (data.signatures)
+      sections.push(`# Signatures
+
+\`\`\`
+${data.signatures}
+\`\`\``);
+    if (data.full)
+      sections.push(`# Full Source
+
+\`\`\`
+${data.full}
+\`\`\``);
+  } else {
+    sections.push(CODEMAP_HINT);
+  }
+  if (config.read.injectDevToolInstructions)
+    sections.push(DEV_TOOL_HINT);
+  return sections.join("\n\n");
+}
+function computeInjection(content, config, data) {
+  const si = content.indexOf(START_TAG);
+  const ei = content.indexOf(END_TAG);
+  if (si === -1 || ei === -1)
+    return null;
+  const oldBody = content.slice(si + START_TAG.length, ei);
+  const newBody = `
+
+${renderSections(config, data)}
+`;
+  if (oldBody === newBody)
+    return null;
+  const before = content.slice(0, si + START_TAG.length);
+  const after = content.slice(ei);
+  return `${before}${newBody}${after}`;
+}
+function injectFile(config, data, filePath) {
+  if (!_fs.existsSync.call(void 0, filePath))
+    return false;
+  const next = computeInjection(_fs.readFileSync.call(void 0, filePath, "utf-8"), config, data);
+  if (next === null)
+    return false;
+  _fs.writeFileSync.call(void 0, filePath, next);
+  return true;
+}
+function injectAll(config, data, files = DEFAULT_INJECT_FILES) {
+  const injected = [];
+  for (const f of files) {
+    if (injectFile(config, data, f))
+      injected.push(f);
+  }
+  return injected;
+}
+
+// src/read/state.ts
+
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var toStateField = (f) => ({
+  name: f.name,
+  init: f.init,
+  domain: f.domain.length ? f.domain : null
+});
+async function buildState(paths, marker = "_loading") {
+  const cwd = _process2.default.cwd();
+  const project = await _chunk3X4FTHLCcjs.openProject.call(void 0, cwd);
+  const inScope = paths ? new Set(paths) : null;
+  const { nodes } = _chunk3X4FTHLCcjs.buildStateGraph.call(void 0, project, (abs) => _path.relative.call(void 0, cwd, abs), marker);
+  const states = [];
+  for (const n of nodes) {
+    const filePath = n.anchor.slice(0, n.anchor.lastIndexOf(":"));
+    if (inScope && !inScope.has(filePath))
+      continue;
+    const decl = _optionalChain([project, 'access', _ => _.getSourceFile, 'call', _2 => _2(_path.resolve.call(void 0, cwd, filePath)), 'optionalAccess', _3 => _3.getVariableDeclarations, 'call', _4 => _4(), 'access', _5 => _5.find, 'call', _6 => _6((v) => v.getName() === n.store)]);
+    if (!decl)
+      continue;
+    const fields = _chunk3X4FTHLCcjs.extractStoreFields.call(void 0, decl, marker);
+    if (fields.length)
+      states.push({ store: n.store, filePath, fields: fields.map(toStateField) });
+  }
+  return states;
+}
+function formatState(states) {
+  const lines = [];
+  for (const s of states) {
+    lines.push(`${s.store}  (${s.filePath})`);
+    for (const f of s.fields) {
+      const dom = f.domain ? `  {${f.domain.join("|")}}` : "";
+      lines.push(`  ${f.name} = ${f.init}${dom}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/read/render.ts
+
+var _ignore = require('ignore'); var _ignore2 = _interopRequireDefault(_ignore);
+var _mdastutilfrommarkdown = require('mdast-util-from-markdown');
+var _nodehtmlparser = require('node-html-parser');
+var _postcss = require('postcss'); var _postcss2 = _interopRequireDefault(_postcss);
+var _postcssless = require('postcss-less'); var _postcssless2 = _interopRequireDefault(_postcssless);
+var _postcssscss = require('postcss-scss'); var _postcssscss2 = _interopRequireDefault(_postcssscss);
+var _webtreesitter = require('web-tree-sitter');
+var _yaml = require('yaml');
+function buildClassifier(detail, defaultLevel = "compact") {
+  const matchers = [];
+  for (const level of ["tree", "full", "compact"]) {
+    const globs = Object.keys(detail).filter((p) => detail[p] === level);
+    if (globs.length)
+      matchers.push({ level, ig: _ignore2.default.call(void 0, ).add(globs) });
+  }
+  return (path) => _nullishCoalesce(_optionalChain([matchers, 'access', _7 => _7.find, 'call', _8 => _8((m) => m.ig.ignores(path)), 'optionalAccess', _9 => _9.level]), () => ( defaultLevel));
+}
+var STACK_INCLUDE = /* @__PURE__ */ new Set([
+  // Platform
+  "electron",
+  "react-native",
+  "@tauri-apps/api",
+  "@capacitor/core",
+  // Meta-framework
+  "next",
+  "nuxt",
+  "@remix-run/react",
+  "astro",
+  "gatsby",
+  "@sveltejs/kit",
+  // UI framework
+  "react",
+  "vue",
+  "svelte",
+  "solid-js",
+  "@angular/core",
+  // Build
+  "vite",
+  "webpack",
+  "esbuild",
+  "@rspack/core",
+  "turbopack",
+  // Monorepo
+  "turbo",
+  "nx",
+  // Language
+  "typescript",
+  // Styling
+  "tailwindcss",
+  "unocss",
+  "styled-components",
+  "@emotion/css",
+  "@emotion/react",
+  "@vanilla-extract/css",
+  // Component lib
+  "class-variance-authority",
+  "@mui/material",
+  "antd",
+  "@chakra-ui/react",
+  "@mantine/core",
+  "@headlessui/react",
+  "element-plus",
+  "@arco-design/web-react",
+  "@arco-design/mobile-react",
+  "naive-ui",
+  "vuetify",
+  // Icons
+  "lucide-react",
+  "@heroicons/react",
+  // Routing
+  "react-router-dom",
+  "@tanstack/react-router",
+  "vue-router",
+  // State
+  "mobx",
+  "zustand",
+  "redux",
+  "@reduxjs/toolkit",
+  "@tanstack/react-query",
+  "jotai",
+  "pinia",
+  "valtio",
+  "xstate",
+  "swr",
+  "@apollo/client",
+  // Forms
+  "react-hook-form",
+  // Animation
+  "framer-motion",
+  "@react-spring/web",
+  // Rich text / Editor
+  "@tiptap/react",
+  "@monaco-editor/react",
+  // DnD
+  "@dnd-kit/core",
+  // Virtualization
+  "@tanstack/react-virtual",
+  // Charts
+  "recharts",
+  "@nivo/core",
+  "d3",
+  // Canvas / Visual
+  "@xyflow/react",
+  "three",
+  "@react-three/fiber",
+  // Testing
+  "vitest",
+  "jest",
+  "@playwright/test",
+  "cypress",
+  // Backend
+  "express",
+  "fastify",
+  "hono",
+  "@nestjs/core",
+  // ORM / DB
+  "drizzle-orm",
+  "prisma",
+  "@prisma/client",
+  "mongoose",
+  // BaaS
+  "@supabase/supabase-js",
+  "firebase",
+  // AI
+  "ai",
+  "@langchain/core",
+  // API
+  "@trpc/server",
+  "graphql",
+  // Storage
+  "dexie"
+]);
+var STACK_COLLAPSE = [
+  { prefix: "@dnd-kit/", label: "dnd-kit" },
+  { prefix: "@tiptap/", label: "tiptap" },
+  { prefix: "@tanstack/react-query", label: "tanstack-query" },
+  { prefix: "@tanstack/react-router", label: "tanstack-router" },
+  { prefix: "@tanstack/react-virtual", label: "tanstack-virtual" },
+  { prefix: "@emotion/", label: "emotion" },
+  { prefix: "@mui/", label: "mui" },
+  { prefix: "@chakra-ui/", label: "chakra" },
+  { prefix: "@mantine/", label: "mantine" },
+  { prefix: "@headlessui/", label: "headless-ui" },
+  { prefix: "@heroicons/", label: "heroicons" },
+  { prefix: "@arco-design/", label: "arco-design" },
+  { prefix: "@nestjs/", label: "nestjs" },
+  { prefix: "@supabase/", label: "supabase" },
+  { prefix: "@langchain/", label: "langchain" },
+  { prefix: "@trpc/", label: "trpc" },
+  { prefix: "@prisma/", label: "prisma" },
+  { prefix: "@remix-run/", label: "remix" },
+  { prefix: "@sveltejs/kit", label: "sveltekit" },
+  { prefix: "@angular/", label: "angular" },
+  { prefix: "@tauri-apps/", label: "tauri" },
+  { prefix: "@capacitor/", label: "capacitor" },
+  { prefix: "@xyflow/", label: "react-flow" },
+  { prefix: "@react-three/", label: "r3f" },
+  { prefix: "@react-spring/", label: "react-spring" },
+  { prefix: "@reduxjs/", label: "redux" },
+  { prefix: "@playwright/", label: "playwright" },
+  { prefix: "@rspack/", label: "rspack" },
+  { prefix: "@monaco-editor/", label: "monaco" },
+  { prefix: "@apollo/", label: "apollo" },
+  { prefix: "@nivo/", label: "nivo" },
+  { prefix: "@vanilla-extract/", label: "vanilla-extract" }
+];
+var STACK_RENAME = {
+  "typescript": "ts",
+  "tailwindcss": "tailwind",
+  "class-variance-authority": "shadcn/ui",
+  "ai": "vercel-ai",
+  "solid-js": "solid",
+  "drizzle-orm": "drizzle",
+  "lucide-react": "lucide"
+};
+var STACK_PRIORITY = {
+  // Platform / runtime
+  "electron": 0,
+  "react-native": 0,
+  "tauri": 0,
+  "capacitor": 0,
+  // Meta-framework
+  "next": 1,
+  "nuxt": 1,
+  "remix": 1,
+  "astro": 1,
+  "gatsby": 1,
+  "sveltekit": 1,
+  // UI framework
+  "react": 2,
+  "vue": 2,
+  "svelte": 2,
+  "solid": 2,
+  "angular": 2,
+  // Bundler + lang
+  "vite": 3,
+  "webpack": 3,
+  "esbuild": 3,
+  "rspack": 3,
+  "turbopack": 3,
+  "ts": 3,
+  // Monorepo
+  "turbo": 4,
+  "nx": 4,
+  // State
+  "mobx": 5,
+  "zustand": 5,
+  "redux": 5,
+  "jotai": 5,
+  "pinia": 5,
+  "valtio": 5,
+  "xstate": 5,
+  // Styling
+  "tailwind": 5,
+  "unocss": 5,
+  "styled-components": 5,
+  "emotion": 5,
+  "vanilla-extract": 5,
+  // Component library
+  "shadcn/ui": 6,
+  "mui": 6,
+  "antd": 6,
+  "chakra": 6,
+  "mantine": 6,
+  "headless-ui": 6,
+  "element-plus": 6,
+  "arco-design": 6,
+  "naive-ui": 6,
+  "vuetify": 6,
+  // Data / network
+  "vercel-ai": 7,
+  "langchain": 7,
+  "tanstack-query": 7,
+  "swr": 7,
+  "apollo": 7,
+  "trpc": 7,
+  "graphql": 7,
+  "drizzle": 7,
+  "prisma": 7,
+  "mongoose": 7,
+  "supabase": 7,
+  "firebase": 7,
+  "dexie": 7,
+  // Testing
+  "vitest": 8,
+  "jest": 8,
+  "playwright": 8,
+  "cypress": 8,
+  // Package manager (detected separately, always first)
+  "bun": -1,
+  "pnpm": -1,
+  "yarn": -1
+};
+function detectStack(pkg, packageManager) {
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const keys = Object.keys(allDeps);
+  const result = [];
+  if (packageManager)
+    result.push(packageManager);
+  for (const dep of keys) {
+    if (!STACK_INCLUDE.has(dep))
+      continue;
+    const collapse = STACK_COLLAPSE.find((c) => dep.startsWith(c.prefix));
+    const label = collapse ? collapse.label : _nullishCoalesce(STACK_RENAME[dep], () => ( dep));
+    if (!result.includes(label))
+      result.push(label);
+  }
+  return result.sort((a, b) => (_nullishCoalesce(STACK_PRIORITY[a], () => ( 7))) - (_nullishCoalesce(STACK_PRIORITY[b], () => ( 7))));
+}
+function detectPackageManager(filePath) {
+  const dir = filePath.includes("/") ? filePath.slice(0, filePath.lastIndexOf("/") + 1) : "./";
+  if (_fs.existsSync.call(void 0, `${dir}bun.lock`))
+    return "bun";
+  if (_fs.existsSync.call(void 0, `${dir}pnpm-lock.yaml`))
+    return "pnpm";
+  if (_fs.existsSync.call(void 0, `${dir}yarn.lock`))
+    return "yarn";
+  return "";
+}
+function compactPackageJson(content, filePath, packageManager = detectPackageManager(filePath)) {
+  try {
+    const pkg = JSON.parse(content);
+    const parts = [];
+    const stack = detectStack(pkg, packageManager);
+    if (stack.length)
+      parts.push(`stack: ${stack.join(", ")}`);
+    if (pkg.scripts)
+      parts.push(`scripts: ${Object.keys(pkg.scripts).join(", ")}`);
+    const meta = [];
+    if (pkg.type)
+      meta.push(`type: ${pkg.type}`);
+    if (pkg.main)
+      meta.push(`main: ${pkg.main}`);
+    if (pkg.workspaces) {
+      const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : _nullishCoalesce(pkg.workspaces.packages, () => ( []));
+      if (ws.length)
+        meta.push(`workspaces: ${ws.join(", ")}`);
+    }
+    if (meta.length)
+      parts.splice(1, 0, meta.join(", "));
+    return parts.join("\n") || "";
+  } catch (e2) {
+    return "";
+  }
+}
+function stripJsonComments(src) {
+  let out = "";
+  for (let i = 0; i < src.length; i++) {
+    if (src[i] === "/" && src[i + 1] === "/") {
+      i += 2;
+      while (i < src.length && src[i] !== "\n") i++;
+      i--;
+    } else if (src[i] === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < src.length && !(src[i] === "*" && src[i + 1] === "/")) i++;
+      i++;
+    } else {
+      out += src[i];
+    }
+  }
+  return out;
+}
+function compactTsconfig(content) {
+  try {
+    const stripped = stripJsonComments(content);
+    const cfg = JSON.parse(stripped);
+    const co = _nullishCoalesce(cfg.compilerOptions, () => ( {}));
+    const parts = [];
+    if (co.target)
+      parts.push(`target: ${co.target}`);
+    if (co.jsx)
+      parts.push(`jsx: ${co.jsx}`);
+    if (co.paths) {
+      const aliases = Object.entries(co.paths).map(([k, v]) => `"${k}": "${_nullishCoalesce(v[0], () => ( ""))}"`).join(", ");
+      parts.push(`paths: { ${aliases} }`);
+    }
+    if (cfg.extends)
+      parts.push(`extends: ${cfg.extends}`);
+    if (cfg.include)
+      parts.push(`include: ${cfg.include.join(", ")}`);
+    return parts.join(", ") || "";
+  } catch (e3) {
+    return "";
+  }
+}
+function compactYaml(content) {
+  let doc;
+  try {
+    doc = _yaml.parse.call(void 0, content);
+  } catch (e4) {
+    return "";
+  }
+  if (!doc || typeof doc !== "object" || Array.isArray(doc))
+    return "";
+  const result = [];
+  for (const [key, val] of Object.entries(doc)) {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const sub = Object.keys(val).slice(0, 12).join(", ");
+      result.push(sub ? `${key}: ${sub}` : key);
+    } else if (Array.isArray(val)) {
+      result.push(`${key}: ${val.slice(0, 8).join(", ")}`);
+    } else if (val != null) {
+      result.push(`${key}: ${val}`);
+    } else {
+      result.push(key);
+    }
+  }
+  return result.join("\n");
+}
+function compactDockerfile(content) {
+  const KEEP = /* @__PURE__ */ new Set(["FROM", "WORKDIR", "EXPOSE", "CMD", "ENTRYPOINT", "ARG"]);
+  const parts = [];
+  let buf = "";
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    if (line.endsWith("\\")) {
+      buf += `${line.slice(0, -1)} `;
+      continue;
+    }
+    const full = (buf + line).trim();
+    buf = "";
+    const spaceIdx = full.indexOf(" ");
+    if (spaceIdx === -1)
+      continue;
+    const cmd = full.slice(0, spaceIdx).toUpperCase();
+    const arg = full.slice(spaceIdx + 1).trim();
+    if (!KEEP.has(cmd))
+      continue;
+    const val = cmd === "ARG" ? arg.slice(0, arg.includes("=") ? arg.indexOf("=") : void 0) : arg;
+    parts.push(`${cmd} ${val}`);
+  }
+  return parts.join("\n");
+}
+function compactCss(content, filename) {
+  const syntax = filename.endsWith(".scss") ? _postcssscss2.default : filename.endsWith(".less") ? _postcssless2.default : void 0;
+  try {
+    const root = syntax ? _postcss2.default.call(void 0, ).process(content, { syntax }).root : _postcss2.default.parse(content);
+    const seen = /* @__PURE__ */ new Set();
+    root.walkDecls((decl) => {
+      if (decl.prop.startsWith("--"))
+        seen.add(decl.prop);
+    });
+    return [...seen].join(", ");
+  } catch (e5) {
+    return "";
+  }
+}
+function compactEnv(content) {
+  const keys = content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && l.includes("=")).map((l) => l.slice(0, l.indexOf("=")));
+  return keys.length ? keys.join(", ") : "";
+}
+function compactHtml(content) {
+  const root = _nodehtmlparser.parse.call(void 0, content);
+  const parts = [];
+  const title = root.querySelector("title");
+  if (_optionalChain([title, 'optionalAccess', _10 => _10.text, 'access', _11 => _11.trim, 'call', _12 => _12()]))
+    parts.push(`title: ${title.text.trim()}`);
+  const SCRIPT_EXTS = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
+  const entry = root.querySelectorAll("script[src]").map((n) => n.getAttribute("src")).find((src) => SCRIPT_EXTS.some((ext) => src.endsWith(ext)));
+  if (entry)
+    parts.push(`entry: ${entry}`);
+  return parts.join(", ") || "";
+}
+function compactMarkdown(content) {
+  const tree = _mdastutilfrommarkdown.fromMarkdown.call(void 0, content);
+  return tree.children.filter((n) => n.type === "heading" && n.depth <= 3).map((n) => {
+    const text = n.children.map((c) => "value" in c ? c.value : "").join("");
+    return `${"#".repeat(n.depth)} ${text}`;
+  }).join("\n");
+}
+var NON_CODE_COMPRESSORS = [
+  { match: (f) => f === "package.json", compress: compactPackageJson },
+  { match: (f) => f.startsWith("tsconfig") && f.endsWith(".json"), compress: (c) => compactTsconfig(c) },
+  { match: (f) => f === ".env" || f.startsWith(".env."), compress: (c) => compactEnv(c) },
+  { match: (f) => f.endsWith(".html"), compress: (c) => compactHtml(c) },
+  { match: (f) => f.endsWith(".yml") || f.endsWith(".yaml"), compress: (c) => compactYaml(c) },
+  { match: (f) => f === "Dockerfile" || f.startsWith("Dockerfile."), compress: (c) => compactDockerfile(c) },
+  { match: (f) => f.endsWith(".css") || f.endsWith(".scss") || f.endsWith(".less"), compress: (c, p) => compactCss(c, p.slice(p.lastIndexOf("/") + 1)) },
+  { match: (f) => f.endsWith(".md"), compress: (c) => compactMarkdown(c) }
+];
+var isWs = (c) => c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === "\v";
+var isDigit = (c) => c >= "0" && c <= "9";
+function extractPort(src) {
+  let from = 0;
+  for (; ; ) {
+    const idx = src.indexOf("port", from);
+    if (idx === -1)
+      return "";
+    from = idx + 4;
+    let i = from;
+    while (i < src.length && isWs(src[i])) i++;
+    if (src[i] !== ":")
+      continue;
+    i++;
+    while (i < src.length && isWs(src[i])) i++;
+    let n = 0;
+    while (i + n < src.length && isDigit(src[i + n])) n++;
+    if (n)
+      return src.slice(i, i + n);
+  }
+}
+function extractAliasKeys(src) {
+  let from = 0;
+  for (; ; ) {
+    const idx = src.indexOf("alias", from);
+    if (idx === -1)
+      return [];
+    from = idx + 5;
+    let i = from;
+    while (i < src.length && isWs(src[i])) i++;
+    if (src[i] !== ":")
+      continue;
+    i++;
+    while (i < src.length && isWs(src[i])) i++;
+    if (src[i] !== "{")
+      continue;
+    const close = src.indexOf("}", i);
+    if (close === -1)
+      continue;
+    return extractQuotedKeys(src.slice(i + 1, close));
+  }
+}
+function extractQuotedKeys(body) {
+  const keys = [];
+  for (let i = 0; i < body.length; i++) {
+    const q = body[i];
+    if (q !== "'" && q !== '"')
+      continue;
+    const end = body.indexOf(q, i + 1);
+    if (end === -1)
+      break;
+    const key = body.slice(i + 1, end);
+    let j = end + 1;
+    while (j < body.length && isWs(body[j])) j++;
+    if (body[j] === ":")
+      keys.push(key);
+    i = end;
+  }
+  return keys;
+}
+async function buildBlocks(paths, config, wasmDir, classifyFn, contents) {
+  await _webtreesitter.Parser.init();
+  const parser = new (0, _webtreesitter.Parser)();
+  const classifyPath = _nullishCoalesce(classifyFn, () => ( buildClassifier(config.read.fileDetailLevel)));
+  const blocks = [];
+  let currentLang = null;
+  for (const path of paths) {
+    const level = classifyPath(path);
+    if (level === "tree") {
+      blocks.push({ path, level, content: "" });
+      continue;
+    }
+    const raw = _nullishCoalesce(_optionalChain([contents, 'optionalAccess', _13 => _13.get, 'call', _14 => _14(path)]), () => ( _fs.readFileSync.call(void 0, path, "utf-8")));
+    if (!raw.trim())
+      continue;
+    if (level === "full") {
+      blocks.push({ path, level, content: raw });
+      continue;
+    }
+    const ext = path.slice(path.lastIndexOf("."));
+    const lang = await _chunkDUUCVLC3cjs.getLang.call(void 0, ext, wasmDir);
+    if (lang && lang !== currentLang) {
+      parser.setLanguage(lang);
+      currentLang = lang;
+    }
+    let tree;
+    if (lang) {
+      tree = _nullishCoalesce(parser.parse(raw), () => ( void 0));
+    }
+    const imports = lang ? _chunkDUUCVLC3cjs.extractImports.call(void 0, raw, parser, lang, tree) : void 0;
+    const filename = path.slice(path.lastIndexOf("/") + 1);
+    let content;
+    if (filename.startsWith("vite.config.") && lang) {
+      const plugins = (_nullishCoalesce(imports, () => ( []))).filter((p) => !p.startsWith("node:") && !p.startsWith(".") && (p.includes("plugin") || p.startsWith("@vitejs/")));
+      const info = [];
+      if (plugins.length)
+        info.push(`plugins: ${plugins.join(", ")}`);
+      const port = extractPort(raw);
+      if (port)
+        info.push(`port: ${port}`);
+      const aliasKeys = extractAliasKeys(raw);
+      if (aliasKeys.length)
+        info.push(`alias: ${aliasKeys.join(", ")}`);
+      content = info.join(", ");
+    } else if (lang) {
+      content = _chunkDUUCVLC3cjs.compact.call(void 0, raw, parser, lang, {
+        skipNoParamFn: !config.read.showNoParamFn
+      }, tree);
+    } else {
+      const c = NON_CODE_COMPRESSORS.find((c2) => c2.match(filename));
+      content = c ? c.compress(raw, path) : "";
+    }
+    _optionalChain([tree, 'optionalAccess', _15 => _15.delete, 'call', _16 => _16()]);
+    if (content.trim())
+      blocks.push({ path, level, content, imports });
+  }
+  parser.delete();
+  return blocks;
+}
+var CODE_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".c",
+  ".cpp",
+  ".cs",
+  ".swift",
+  ".kt"
+]);
+function getExt(name) {
+  return name.includes(".") ? name.slice(name.lastIndexOf(".")) : "(no ext)";
+}
+var isHex = (c) => c >= "0" && c <= "9" || c >= "a" && c <= "f" || c >= "A" && c <= "F";
+var isAlpha = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+function classSeq(stem) {
+  let out = "";
+  let prev = "";
+  for (const c of stem) {
+    const cls = isHex(c) ? "H" : isAlpha(c) ? "A" : c === "-" || c === "_" || c === "." ? "S" : "X";
+    if (cls !== prev) {
+      out += cls;
+      prev = cls;
+    }
+  }
+  return out;
+}
+var HOMOGENEOUS_FOLD_MIN = 3;
+function formatTree(paths, foldThreshold = 8, opts = {}) {
+  const { skeletonOnly = false, kept, collapsedDirs, starred } = opts;
+  const star = (fullPath) => _optionalChain([starred, 'optionalAccess', _17 => _17.has, 'call', _18 => _18(fullPath)]) ? " \u2605" : "";
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const path of paths) {
+    const parts = path.split("/");
+    let node = root;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!node.children.has(parts[i]))
+        node.children.set(parts[i], { children: /* @__PURE__ */ new Map() });
+      node = node.children.get(parts[i]);
+    }
+    node.children.set(parts[parts.length - 1], { children: /* @__PURE__ */ new Map(), file: true });
+  }
+  function mergeExt(exts, ext, incoming) {
+    const existing = exts.get(ext);
+    if (!existing) {
+      exts.set(ext, { ...incoming });
+      return;
+    }
+    const count = existing.count + incoming.count;
+    exts.set(ext, { count });
+  }
+  function annotate(node) {
+    const exts = /* @__PURE__ */ new Map();
+    let count = 0;
+    let dirCount = 0;
+    let hasCode = false;
+    for (const [name, child] of node.children) {
+      if (child.file) {
+        const ext = getExt(name);
+        mergeExt(exts, ext, { count: 1, name });
+        count++;
+        if (CODE_EXTS.has(ext))
+          hasCode = true;
+      } else {
+        annotate(child);
+        count += _nullishCoalesce(child.subtreeCount, () => ( 0));
+        dirCount += 1 + (_nullishCoalesce(child.subtreeDirCount, () => ( 0)));
+        if (child.hasCode)
+          hasCode = true;
+        for (const [ext, entry] of _nullishCoalesce(child.subtreeExts, () => ( [])))
+          mergeExt(exts, ext, entry);
+      }
+    }
+    node.hasCode = hasCode;
+    node.subtreeExts = exts;
+    node.subtreeCount = count;
+    node.subtreeDirCount = dirCount;
+  }
+  annotate(root);
+  const lines = [];
+  const FOLD_DIRS = /* @__PURE__ */ new Set(["ui", "icons"]);
+  const leafFileNames = (n) => {
+    const names = [];
+    for (const [name, c] of n.children) {
+      if (!c.file)
+        return null;
+      names.push(name);
+    }
+    return names;
+  };
+  function foldSiblingDirs(dirEntries) {
+    const groups = /* @__PURE__ */ new Map();
+    const rest = [];
+    for (const [name, c] of dirEntries) {
+      const names = leafFileNames(c);
+      if (!names || !names.length) {
+        rest.push([name, c]);
+        continue;
+      }
+      const sorted = [...names].sort();
+      const sig = `N:${sorted.join("|")}`;
+      groups.set(sig, [..._nullishCoalesce(groups.get(sig), () => ( [])), { entry: [name, c], names: sorted }]);
+    }
+    const extGroups = /* @__PURE__ */ new Map();
+    for (const [sig, arr] of [...groups]) {
+      if (arr.length >= HOMOGENEOUS_FOLD_MIN)
+        continue;
+      groups.delete(sig);
+      for (const item of arr) {
+        const extSig = `E:${item.names.map(getExt).sort().join("|")}`;
+        extGroups.set(extSig, [..._nullishCoalesce(extGroups.get(extSig), () => ( [])), item]);
+      }
+    }
+    const folded = [];
+    const emit = (arr, byName) => {
+      const sample = arr[0].names;
+      const body = byName ? sample.join(", ") : [...new Set(sample.map(getExt))].map((e) => {
+        const n = sample.filter((name) => getExt(name) === e).length;
+        return n > 1 ? `${e} \xD7${n}` : e;
+      }).join(", ");
+      folded.push(`[name]/ (${body}) \xD7${arr.length}`);
+    };
+    for (const arr of groups.values()) {
+      if (arr.length >= HOMOGENEOUS_FOLD_MIN)
+        emit(arr, true);
+      else arr.forEach((i) => rest.push(i.entry));
+    }
+    for (const arr of extGroups.values()) {
+      if (arr.length >= HOMOGENEOUS_FOLD_MIN)
+        emit(arr, false);
+      else arr.forEach((i) => rest.push(i.entry));
+    }
+    return { folded, rest };
+  }
+  function foldHomogeneousFiles(fileEntries) {
+    const stemOf = (name) => {
+      const ext = getExt(name);
+      return ext === "(no ext)" ? name : name.slice(0, name.length - ext.length);
+    };
+    const isPureId = (stem) => stem.length > 0 && [...stem].every((c) => isHex(c) || c === "-" || c === "_");
+    const groups = /* @__PURE__ */ new Map();
+    const rest = [];
+    for (const [name, c] of fileEntries) {
+      const stem = stemOf(name);
+      if (!isPureId(stem)) {
+        rest.push([name, c]);
+        continue;
+      }
+      const key = `${classSeq(stem)}|${getExt(name)}`;
+      groups.set(key, [..._nullishCoalesce(groups.get(key), () => ( [])), [name, c]]);
+    }
+    const folded = [];
+    for (const entries of groups.values()) {
+      if (entries.length >= HOMOGENEOUS_FOLD_MIN) {
+        const ext = getExt(entries[0][0]);
+        folded.push(`[id]${ext === "(no ext)" ? "" : ext} \xD7${entries.length}`);
+      } else {
+        rest.push(...entries);
+      }
+    }
+    return { folded, rest };
+  }
+  function walk(node, prefix, dirName, dirPath = "") {
+    let rawEntries = Array.from(node.children.entries());
+    const unkeptExtLines = [];
+    if (_optionalChain([kept, 'optionalAccess', _19 => _19.size])) {
+      const unkept = rawEntries.filter(([name, c]) => c.file && !kept.has(dirPath ? `${dirPath}/${name}` : name));
+      if (unkept.length) {
+        rawEntries = rawEntries.filter(([name, c]) => !(c.file && !kept.has(dirPath ? `${dirPath}/${name}` : name)));
+        const extCounts = /* @__PURE__ */ new Map();
+        for (const [name] of unkept) extCounts.set(getExt(name), (_nullishCoalesce(extCounts.get(getExt(name)), () => ( 0))) + 1);
+        for (const [ext, n] of [...extCounts.entries()].sort((a, b) => b[1] - a[1]))
+          unkeptExtLines.push(`${ext} \xD7${n}`);
+      }
+    }
+    const codeItems = rawEntries.filter(([name, c]) => c.file ? CODE_EXTS.has(getExt(name)) : !!c.hasCode);
+    const nonCodeItems = rawEntries.filter(([name, c]) => c.file ? !CODE_EXTS.has(getExt(name)) : !c.hasCode);
+    const nonCodeItemCount = nonCodeItems.length;
+    const items = [];
+    if (skeletonOnly) {
+      const dirs = rawEntries.filter(([, c]) => !c.file);
+      const fileCount = rawEntries.length - dirs.length;
+      const branchDirs = dirs.filter(([, c]) => [...c.children.values()].some((ch) => !ch.file));
+      const leafDirs = dirs.filter(([, c]) => ![...c.children.values()].some((ch) => !ch.file));
+      const { folded, rest } = foldSiblingDirs(leafDirs);
+      for (const [name, c] of rest)
+        items.push({ display: `${name}/  ${c.children.size} file${c.children.size > 1 ? "s" : ""}` });
+      for (const d of folded) items.push({ display: d });
+      for (const [name, c] of branchDirs) items.push({ display: name, child: c });
+      if (fileCount > 0)
+        items.push({ display: `${fileCount} file${fileCount > 1 ? "s" : ""}` });
+      return emitItems(items, prefix);
+    }
+    const codeFiles = codeItems.filter(([, c]) => c.file);
+    const codeDirs = codeItems.filter(([, c]) => !c.file);
+    if (dirName && FOLD_DIRS.has(dirName) && codeFiles.length > 1 && codeDirs.length === 0) {
+      const ext = getExt(codeFiles[0][0]);
+      const allSameExt = codeFiles.every(([name]) => getExt(name) === ext);
+      if (allSameExt) {
+        items.push({ display: `${ext} \xD7${codeFiles.length}` });
+      } else {
+        const extCounts = /* @__PURE__ */ new Map();
+        for (const [name] of codeFiles) {
+          const e = getExt(name);
+          extCounts.set(e, (_nullishCoalesce(extCounts.get(e), () => ( 0))) + 1);
+        }
+        for (const [ext2, count] of [...extCounts.entries()].sort((a, b) => b[1] - a[1]))
+          items.push({ display: `${ext2} \xD7${count}` });
+      }
+    } else {
+      const { folded: foldedDirs, rest: restDirs } = foldSiblingDirs(codeDirs);
+      const { folded: foldedFiles, rest: restFiles } = foldHomogeneousFiles(codeFiles);
+      for (const [name] of restFiles)
+        items.push({ display: name, child: void 0 });
+      for (const [name, c] of restDirs)
+        items.push({ display: name, child: c });
+      for (const d of foldedFiles) items.push({ display: d });
+      for (const d of foldedDirs) items.push({ display: d });
+    }
+    if (nonCodeItemCount > foldThreshold) {
+      const extCounts = /* @__PURE__ */ new Map();
+      for (const [name, c] of nonCodeItems) {
+        if (c.file) {
+          mergeExt(extCounts, getExt(name), { count: 1, name });
+        } else {
+          for (const [ext, entry] of _nullishCoalesce(c.subtreeExts, () => ( []))) mergeExt(extCounts, ext, entry);
+        }
+      }
+      for (const [ext, entry] of [...extCounts.entries()].sort((a, b) => b[1].count - a[1].count))
+        items.push({ display: entry.count === 1 && entry.name ? entry.name : `${ext} \xD7${entry.count}` });
+    } else {
+      const ncDirs = nonCodeItems.filter(([, c]) => !c.file);
+      const ncFiles = nonCodeItems.filter(([, c]) => c.file);
+      const { folded: foldedDirs, rest: restDirs } = foldSiblingDirs(ncDirs);
+      const { folded: foldedFiles, rest: restFiles } = foldHomogeneousFiles(ncFiles);
+      for (const [name] of restFiles)
+        items.push({ display: name, child: void 0 });
+      for (const [name, c] of restDirs)
+        items.push({ display: name, child: c });
+      for (const d of foldedFiles) items.push({ display: d });
+      for (const d of foldedDirs) items.push({ display: d });
+    }
+    for (const line of unkeptExtLines)
+      items.push({ display: line });
+    return emitItems(items, prefix, dirPath);
+  }
+  function emitItems(items, prefix, dirPath = "") {
+    for (const { display, child } of items) {
+      if (child) {
+        const childPath = dirPath ? `${dirPath}/${display}` : display;
+        if (_optionalChain([collapsedDirs, 'optionalAccess', _20 => _20.has, 'call', _21 => _21(childPath)])) {
+          const files = _nullishCoalesce(child.subtreeCount, () => ( 0));
+          const dirs = _nullishCoalesce(child.subtreeDirCount, () => ( 0));
+          lines.push(`${prefix}${display}/ (${files} file${files === 1 ? "" : "s"}, ${dirs} dir${dirs === 1 ? "" : "s"})`);
+          continue;
+        }
+        let label = display;
+        let cur = child;
+        let fileLeaf = false;
+        while (cur.children.size === 1) {
+          const [onlyName, onlyChild] = [...cur.children][0];
+          label += `/${onlyName}`;
+          if (onlyChild.file) {
+            lines.push(`${prefix}${label}${star(dirPath ? `${dirPath}/${label}` : label)}`);
+            fileLeaf = true;
+            break;
+          }
+          cur = onlyChild;
+        }
+        if (fileLeaf)
+          continue;
+        lines.push(`${prefix}${label}/`);
+        walk(cur, `${prefix}  `, label.slice(label.lastIndexOf("/") + 1), dirPath ? `${dirPath}/${label}` : label);
+      } else {
+        lines.push(`${prefix}${display}${star(dirPath ? `${dirPath}/${display}` : display)}`);
+      }
+    }
+  }
+  walk(root, "");
+  return lines.join("\n");
+}
+function formatStarredTree(paths, starred) {
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const path of paths) {
+    const parts = path.split("/");
+    let node = root;
+    for (let i = 0; i < parts.length; i++) {
+      const isLeaf = i === parts.length - 1;
+      if (!node.children.has(parts[i]))
+        node.children.set(parts[i], { children: /* @__PURE__ */ new Map() });
+      node = node.children.get(parts[i]);
+      if (isLeaf) {
+        node.file = true;
+        node.fullPath = path;
+      }
+    }
+  }
+  const hasStar = (n) => {
+    if (n.file) return !!(n.fullPath && starred.has(n.fullPath));
+    for (const c of n.children.values()) if (hasStar(c)) return true;
+    return false;
+  };
+  const countNonStar = (n) => {
+    if (n.file) return n.fullPath && starred.has(n.fullPath) ? 0 : 1;
+    let s = 0;
+    for (const c of n.children.values()) s += countNonStar(c);
+    return s;
+  };
+  const lines = [];
+  const walk = (node, prefix) => {
+    const entries = [...node.children.entries()];
+    const starDirs = entries.filter(([, c]) => !c.file && hasStar(c));
+    const starFiles = entries.filter(([, c]) => c.file && hasStar(c));
+    let hidden = 0;
+    for (const [, c] of entries)
+      if (!hasStar(c)) hidden += countNonStar(c);
+    for (const [name, c] of starFiles)
+      lines.push(`${prefix}${name} \u2605`);
+    for (const [name, c] of starDirs) {
+      lines.push(`${prefix}${name}/`);
+      walk(c, `${prefix}  `);
+    }
+    if (hidden > 0)
+      lines.push(`${prefix}\u2026 ${hidden} more`);
+  };
+  walk(root, "");
+  return lines.join("\n");
+}
+function formatXml(blocks, levels) {
+  return blocks.filter((b) => {
+    if (levels && !levels.has(b.path))
+      return false;
+    const level = _nullishCoalesce(_optionalChain([levels, 'optionalAccess', _22 => _22.get, 'call', _23 => _23(b.path)]), () => ( b.level));
+    return level !== "tree" && b.content.trim();
+  }).map((b) => `<file path="${b.path}">
+${b.content}
+</file>`).join("\n\n");
+}
+
+// src/read/security.ts
+var isDigit2 = (c) => c >= "0" && c <= "9";
+var isUpper = (c) => c >= "A" && c <= "Z";
+var isLower = (c) => c >= "a" && c <= "z";
+var isAlpha2 = (c) => isUpper(c) || isLower(c);
+var isAlphaNum = (c) => isAlpha2(c) || isDigit2(c);
+var isWord = (c) => isAlphaNum(c) || c === "_";
+var isSpace = (c) => c === " " || c === "	" || c === "\f" || c === "\v";
+var isBearerChar = (c) => isWord(c) || c === "-" || c === "." || c === "~" || c === "+" || c === "/";
+function runLen(line, i, pred) {
+  let n = 0;
+  while (i + n < line.length && pred(line[i + n]))
+    n++;
+  return n;
+}
+function hasAwsKey(line) {
+  for (let i = 0; i + 4 <= line.length; i++) {
+    if (line.startsWith("AKIA", i)) {
+      const run = runLen(line, i + 4, (c) => isDigit2(c) || isUpper(c));
+      if (run >= 16)
+        return true;
+    }
+  }
+  return false;
+}
+var SECRET_KEYWORDS = ["secret", "password", "passwd", "token", "api_key", "apikey", "api-key", "auth"];
+function hasGenericSecret(line) {
+  const lower = line.toLowerCase();
+  for (const kw of SECRET_KEYWORDS) {
+    let from = 0;
+    for (; ; ) {
+      const idx = lower.indexOf(kw, from);
+      if (idx === -1)
+        break;
+      from = idx + 1;
+      let j = idx + kw.length;
+      while (j < line.length && isSpace(line[j])) j++;
+      if (line[j] !== "=" && line[j] !== ":")
+        continue;
+      j++;
+      while (j < line.length && isSpace(line[j])) j++;
+      const quote = line[j];
+      if (quote !== "'" && quote !== '"')
+        continue;
+      j++;
+      const valStart = j;
+      while (j < line.length && line[j] !== quote && line[j] !== " " && line[j] !== "	" && line[j] !== "\f" && line[j] !== "\v" && line[j] !== "'" && line[j] !== '"')
+        j++;
+      if (j - valStart >= 8 && line[j] === quote)
+        return true;
+    }
+  }
+  return false;
+}
+function hasPrivateKey(line) {
+  const i = line.indexOf("-----BEGIN ");
+  if (i === -1)
+    return false;
+  let rest = line.slice(i + "-----BEGIN ".length);
+  for (const prefix of ["RSA ", "EC ", "DSA "]) {
+    if (rest.startsWith(prefix)) {
+      rest = rest.slice(prefix.length);
+      break;
+    }
+  }
+  return rest.startsWith("PRIVATE KEY-----");
+}
+function hasBearerToken(line) {
+  const lower = line.toLowerCase();
+  let from = 0;
+  for (; ; ) {
+    const idx = lower.indexOf("bearer", from);
+    if (idx === -1)
+      return false;
+    from = idx + 1;
+    let j = idx + "bearer".length;
+    const spaces = runLen(line, j, isSpace);
+    if (spaces === 0)
+      continue;
+    j += spaces;
+    if (runLen(line, j, isBearerChar) >= 20)
+      return true;
+  }
+}
+function hasGitHubToken(line) {
+  for (let i = 0; i + 4 <= line.length; i++) {
+    if (line[i] === "g" && line[i + 1] === "h" && (line[i + 2] === "p" || line[i + 2] === "s") && line[i + 3] === "_") {
+      if (runLen(line, i + 4, isWord) >= 36)
+        return true;
+    }
+  }
+  return false;
+}
+var SLACK_KINDS = "bpors";
+function hasSlackToken(line) {
+  for (let i = 0; i + 5 <= line.length; i++) {
+    if (line.startsWith("xox", i) && SLACK_KINDS.includes(line[i + 3]) && line[i + 4] === "-") {
+      if (runLen(line, i + 5, (c) => isAlphaNum(c) || c === "-") >= 10)
+        return true;
+    }
+  }
+  return false;
+}
+var API_PREFIXES = ["sk", "pk", "key"];
+function hasGenericApiKey(line) {
+  for (const prefix of API_PREFIXES) {
+    let from = 0;
+    for (; ; ) {
+      const idx = line.indexOf(`${prefix}-`, from);
+      if (idx === -1)
+        break;
+      from = idx + 1;
+      if (runLen(line, idx + prefix.length + 1, isAlphaNum) >= 20)
+        return true;
+    }
+  }
+  return false;
+}
+var SECRET_PATTERNS = [
+  { name: "AWS Key", match: hasAwsKey },
+  { name: "Generic Secret", match: hasGenericSecret },
+  { name: "Private Key", match: hasPrivateKey },
+  { name: "Bearer Token", match: hasBearerToken },
+  { name: "GitHub Token", match: hasGitHubToken },
+  { name: "Slack Token", match: hasSlackToken },
+  { name: "Generic API Key", match: hasGenericApiKey }
+];
+function scanSecrets(blocks) {
+  const matches = [];
+  for (const block of blocks) {
+    if (!block.content)
+      continue;
+    const lines = block.content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      for (const { name, match } of SECRET_PATTERNS) {
+        if (match(lines[i])) {
+          matches.push({ path: block.path, line: i + 1, pattern: name });
+        }
+      }
+    }
+  }
+  return matches;
+}
+
+// src/read/signals.ts
+var _child_process = require('child_process');
+
+
+
+var estimateTokens = (s) => Math.ceil(s.length / 4);
+function parseRecency(gitLogOutput, files, cwdFromRoot) {
+  const scores = new Map(files.map((f) => [f, 0]));
+  const commits = [];
+  let block = [];
+  for (const raw of gitLogOutput.split("\n")) {
+    const l = raw.trim();
+    if (l) {
+      block.push(l);
+    } else if (block.length) {
+      commits.push(block);
+      block = [];
+    }
+  }
+  if (block.length)
+    commits.push(block);
+  const firstSeen = /* @__PURE__ */ new Map();
+  for (const [i, commitFiles] of commits.entries()) {
+    for (const f of commitFiles) {
+      if (!firstSeen.has(f))
+        firstSeen.set(f, i);
+    }
+  }
+  for (const [gitPath, commitIdx] of firstSeen) {
+    const cwdPath = cwdFromRoot ? _path.relative.call(void 0, cwdFromRoot, gitPath) : gitPath;
+    if (scores.has(cwdPath))
+      scores.set(cwdPath, commitIdx < 5 ? 2 : commitIdx < 20 ? 1 : 0);
+  }
+  return scores;
+}
+function computeRecency(files, cwd = _process2.default.cwd()) {
+  try {
+    const gitRoot = _child_process.execSync.call(void 0, "git rev-parse --show-toplevel", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const out = _child_process.execSync.call(void 0, "git log --name-only --pretty=format: -n 50", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return parseRecency(out, files, _path.relative.call(void 0, gitRoot, _path.resolve.call(void 0, cwd)));
+  } catch (e6) {
+    return new Map(files.map((f) => [f, 0]));
+  }
+}
+var EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function loadPathAliases(cwd) {
+  for (const name of ["tsconfig.app.json", "tsconfig.json"]) {
+    const p = _path.join.call(void 0, cwd, name);
+    if (!_fs.existsSync.call(void 0, p))
+      continue;
+    try {
+      const stripped = stripJsonComments(_fs.readFileSync.call(void 0, p, "utf-8"));
+      const paths = _nullishCoalesce(_optionalChain([JSON, 'access', _24 => _24.parse, 'call', _25 => _25(stripped), 'optionalAccess', _26 => _26.compilerOptions, 'optionalAccess', _27 => _27.paths]), () => ( {}));
+      const noStar = (s) => s.endsWith("*") ? s.slice(0, -1) : s;
+      return Object.entries(paths).map(([key, vals]) => {
+        const target = noStar(vals[0]);
+        return {
+          prefix: noStar(key),
+          // "@/*" → "@/"
+          target: target.startsWith("./") ? target.slice(2) : target
+          // "./src/" → "src/"
+        };
+      });
+    } catch (e7) {
+      continue;
+    }
+  }
+  return [];
+}
+function resolveImport(fromFile, specifier, aliases, diskCache, fileExists) {
+  let base;
+  const alias = aliases.find((a) => specifier.startsWith(a.prefix));
+  if (alias) {
+    base = alias.target + specifier.slice(alias.prefix.length);
+  } else if (specifier.startsWith(".")) {
+    const dir = _path.dirname.call(void 0, fromFile);
+    base = _path.join.call(void 0, dir, specifier);
+  } else {
+    return null;
+  }
+  const cached = diskCache.get(base);
+  if (cached !== void 0)
+    return cached;
+  for (const ext of EXTENSIONS) {
+    if (fileExists(base + ext)) {
+      diskCache.set(base, base + ext);
+      return base + ext;
+    }
+    const idx = _path.join.call(void 0, base, `index${ext}`);
+    if (fileExists(idx)) {
+      diskCache.set(base, idx);
+      return idx;
+    }
+  }
+  diskCache.set(base, null);
+  return null;
+}
+function buildImportGraphPure(blocks, aliases, fileExists) {
+  const diskCache = /* @__PURE__ */ new Map();
+  const graph = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (!_optionalChain([block, 'access', _28 => _28.imports, 'optionalAccess', _29 => _29.length]))
+      continue;
+    for (const specifier of block.imports) {
+      const resolved = resolveImport(block.path, specifier, aliases, diskCache, fileExists);
+      if (!resolved)
+        continue;
+      if (!graph.has(resolved))
+        graph.set(resolved, /* @__PURE__ */ new Set());
+      graph.get(resolved).add(block.path);
+    }
+  }
+  return graph;
+}
+function buildImportGraph(blocks, cwd = _process2.default.cwd()) {
+  return buildImportGraphPure(blocks, loadPathAliases(cwd), _fs.existsSync);
+}
+function computeCentrality(files, graph) {
+  return new Map(files.map((f) => {
+    const count = _nullishCoalesce(_optionalChain([graph, 'access', _30 => _30.get, 'call', _31 => _31(f), 'optionalAccess', _32 => _32.size]), () => ( 0));
+    return [f, count >= 20 ? 2 : count >= 5 ? 1 : 0];
+  }));
+}
+function expandByBudget(paths, scores, contentTokens, budget, treeEntryTokens = 8) {
+  const root = { path: "", isFile: false, score: -1, cost: 0, children: [] };
+  const byPath = /* @__PURE__ */ new Map([["", root]]);
+  for (const path of paths) {
+    const parts = path.split("/");
+    let prefix = "";
+    let parent = root;
+    for (let i = 0; i < parts.length; i++) {
+      prefix = prefix ? `${prefix}/${parts[i]}` : parts[i];
+      let node = byPath.get(prefix);
+      if (!node) {
+        const isFile = i === parts.length - 1;
+        node = {
+          path: prefix,
+          isFile,
+          score: isFile ? _nullishCoalesce(scores.get(path), () => ( 0)) : -1,
+          cost: isFile ? (_nullishCoalesce(contentTokens.get(path), () => ( 0))) + treeEntryTokens : treeEntryTokens,
+          children: []
+        };
+        byPath.set(prefix, node);
+        parent.children.push(node);
+      }
+      parent = node;
+    }
+  }
+  const aggregate = (node) => {
+    if (node.isFile)
+      return node.score;
+    node.score = node.children.reduce((m, c) => Math.max(m, aggregate(c)), node.score);
+    return node.score;
+  };
+  aggregate(root);
+  const kept = /* @__PURE__ */ new Set();
+  const collapsedDirs = /* @__PURE__ */ new Set();
+  const frontier = [...root.children];
+  let spent = 0;
+  while (frontier.length) {
+    let bestIdx = 0;
+    for (let i = 1; i < frontier.length; i++) {
+      if (frontier[i].score > frontier[bestIdx].score)
+        bestIdx = i;
+    }
+    const node = frontier.splice(bestIdx, 1)[0];
+    if (spent + node.cost > budget) {
+      if (!node.isFile)
+        collapsedDirs.add(node.path);
+      continue;
+    }
+    spent += node.cost;
+    kept.add(node.path);
+    if (!node.isFile)
+      frontier.push(...node.children);
+  }
+  return { kept, collapsedDirs };
+}
+var TREE_ENTRY_TOKENS = 8;
+function allocate(blocks, recency, centrality, budget, pinned, isTreeDisplay) {
+  const levels = new Map(blocks.map((b) => [b.path, b.level]));
+  const contentTokens = new Map(blocks.map((b) => [
+    b.path,
+    _optionalChain([isTreeDisplay, 'optionalCall', _33 => _33(b.path)]) ? 0 : estimateTokens(b.content) + estimateTokens(`<file path="${b.path}">
+
+</file>
+
+`)
+  ]));
+  const scores = new Map(
+    blocks.map((b) => [b.path, (_nullishCoalesce(recency.get(b.path), () => ( 0))) + (_nullishCoalesce(centrality.get(b.path), () => ( 0)))])
+  );
+  let total = blocks.reduce((sum, b) => sum + (_nullishCoalesce(contentTokens.get(b.path), () => ( 0))) + TREE_ENTRY_TOKENS, 0);
+  const totalBefore = total;
+  let downgraded = 0;
+  const done = () => ({ levels, totalBefore, totalAfter: total, downgraded, deficit: Math.max(0, total - budget), scores, contentTokens, treeEntryTokens: TREE_ENTRY_TOKENS });
+  if (total <= budget)
+    return done();
+  const sorted = [...blocks].sort((a, b) => (_nullishCoalesce(scores.get(a.path), () => ( 0))) - (_nullishCoalesce(scores.get(b.path), () => ( 0))));
+  for (const block of sorted) {
+    if (total <= budget)
+      break;
+    if (_optionalChain([pinned, 'optionalAccess', _34 => _34.has, 'call', _35 => _35(block.path)]))
+      continue;
+    if (levels.get(block.path) === "compact") {
+      total -= _nullishCoalesce(contentTokens.get(block.path), () => ( 0));
+      levels.set(block.path, "tree");
+      downgraded++;
+    }
+  }
+  return done();
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ensureMarkers = ensureMarkers; exports.renderSections = renderSections; exports.injectFile = injectFile; exports.injectAll = injectAll; exports.buildState = buildState; exports.formatState = formatState; exports.buildClassifier = buildClassifier; exports.buildBlocks = buildBlocks; exports.formatTree = formatTree; exports.formatStarredTree = formatStarredTree; exports.formatXml = formatXml; exports.scanSecrets = scanSecrets; exports.computeRecency = computeRecency; exports.buildImportGraph = buildImportGraph; exports.computeCentrality = computeCentrality; exports.expandByBudget = expandByBudget; exports.allocate = allocate;