@stainless-code/codemap 0.1.0

package/dist/parser-VtP0EJiw.mjs

@@ -0,0 +1,481 @@
+#!/usr/bin/env node
+
+import { extname } from "node:path";
+import { transform } from "lightningcss";
+import { createHash } from "node:crypto";
+import { Visitor, parseSync } from "oxc-parser";
+//#region src/constants.ts
+const LANG_MAP = {
+	".ts": "ts",
+	".tsx": "tsx",
+	".mts": "mts",
+	".cts": "cts",
+	".js": "js",
+	".jsx": "jsx",
+	".mjs": "mjs",
+	".cjs": "cjs",
+	".css": "css",
+	".md": "md",
+	".mdx": "mdx",
+	".mdc": "mdc",
+	".yml": "yaml",
+	".yaml": "yaml",
+	".txt": "txt",
+	".json": "json",
+	".sh": "sh"
+};
+//#endregion
+//#region src/markers.ts
+const MARKER_RE = /\b(TODO|FIXME|HACK|NOTE)[\s:]+(.+)/g;
+function extractMarkers(source, filePath) {
+	const markers = [];
+	MARKER_RE.lastIndex = 0;
+	let match;
+	let lineNum = 1;
+	let lastIdx = 0;
+	while ((match = MARKER_RE.exec(source)) !== null) {
+		for (let i = lastIdx; i < match.index; i++) if (source.charCodeAt(i) === 10) lineNum++;
+		lastIdx = match.index;
+		markers.push({
+			file_path: filePath,
+			line_number: lineNum,
+			kind: match[1],
+			content: match[2].trim()
+		});
+	}
+	return markers;
+}
+//#endregion
+//#region src/css-parser.ts
+function extractCssData(filePath, source, relPath) {
+	const variables = [];
+	const classes = [];
+	const keyframes = [];
+	const markers = [];
+	const importSources = [];
+	const isModule = relPath.endsWith(".module.css");
+	const seenClasses = /* @__PURE__ */ new Set();
+	try {
+		transform({
+			filename: filePath,
+			code: Buffer.from(source),
+			errorRecovery: true,
+			analyzeDependencies: true,
+			customAtRules: { theme: { body: "declaration-list" } },
+			visitor: {
+				Declaration: { custom(property) {
+					variables.push({
+						file_path: relPath,
+						name: property.name,
+						value: stringifyCssValue(property.value),
+						scope: ":root",
+						line_number: property.loc?.line ?? 0
+					});
+				} },
+				Rule: {
+					style(rule) {
+						const line = rule.value.loc?.line ?? 0;
+						extractClassNames(rule.value.selectors, relPath, isModule, line, classes, seenClasses);
+					},
+					keyframes(rule) {
+						const name = rule.value.name;
+						if (typeof name === "string") keyframes.push({
+							file_path: relPath,
+							name,
+							line_number: rule.value.loc?.line ?? 0
+						});
+						else if (name && typeof name === "object" && "value" in name) keyframes.push({
+							file_path: relPath,
+							name: name.value,
+							line_number: rule.value.loc?.line ?? 0
+						});
+					},
+					custom: { theme(rule) {
+						const decls = rule.body?.value;
+						if (decls && typeof decls === "object") {
+							const declarations = decls.declarations ?? [];
+							for (const decl of declarations) if (decl.property === "custom" && decl.value?.name) variables.push({
+								file_path: relPath,
+								name: decl.value.name,
+								value: stringifyCssValue(decl.value.value),
+								scope: "@theme",
+								line_number: decl.value.loc?.line ?? 0
+							});
+						}
+					} }
+				}
+			}
+		});
+	} catch {
+		const lines = source.split("\n");
+		extractCssVariablesRegex(lines, relPath, variables);
+		extractCssClassesRegex(lines, relPath, isModule, classes, seenClasses);
+		extractCssKeyframesRegex(lines, relPath, keyframes);
+	}
+	extractImportSources(source, importSources);
+	markers.push(...extractMarkers(source, relPath));
+	return {
+		variables,
+		classes,
+		keyframes,
+		markers,
+		importSources
+	};
+}
+function stringifyCssValue(value) {
+	if (!value) return "";
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map((v) => stringifyToken(v)).join(" ");
+	return JSON.stringify(value);
+}
+function stringifyToken(token) {
+	if (!token) return "";
+	if (typeof token === "string") return token;
+	if (token.type === "length") return `${token.value?.value ?? 0}${token.value?.unit ?? ""}`;
+	if (token.type === "percentage") return `${token.value ?? 0}%`;
+	if (token.type === "color") return stringifyColor(token.value);
+	if (token.type === "token") {
+		const t = token.value;
+		if (t?.type === "ident") return t.value;
+		if (t?.type === "number") return String(t.value);
+		if (t?.type === "dimension") return `${t.value}${t.unit ?? ""}`;
+		if (t?.type === "comma") return ",";
+		if (t?.type === "string") return `"${t.value}"`;
+		return t?.value ?? "";
+	}
+	if (token.type === "var") return `var(${token.value?.name ?? ""})`;
+	if (token.type === "env") return `env(${token.value?.name ?? ""})`;
+	return "";
+}
+function stringifyColor(color) {
+	if (!color) return "";
+	if (color.type === "rgb") return `rgb(${color.r}, ${color.g}, ${color.b})`;
+	if (color.type === "rgba") return `rgba(${color.r}, ${color.g}, ${color.b}, ${color.alpha})`;
+	return JSON.stringify(color);
+}
+function extractClassNames(selectors, filePath, isModule, line, classes, seen) {
+	if (!selectors) return;
+	for (const selector of selectors) for (const component of selector) if (component.type === "class" && !seen.has(component.name)) {
+		seen.add(component.name);
+		classes.push({
+			file_path: filePath,
+			name: component.name,
+			is_module: isModule ? 1 : 0,
+			line_number: line
+		});
+	}
+}
+const CSS_VAR_RE = /^\s*(--[\w-]+)\s*:\s*(.+?)\s*;/gm;
+function extractCssVariablesRegex(lines, filePath, variables) {
+	for (let i = 0; i < lines.length; i++) {
+		CSS_VAR_RE.lastIndex = 0;
+		const match = CSS_VAR_RE.exec(lines[i]);
+		if (match) variables.push({
+			file_path: filePath,
+			name: match[1],
+			value: match[2],
+			scope: "unknown",
+			line_number: i + 1
+		});
+	}
+}
+const CSS_CLASS_RE = /\.([a-zA-Z_][\w-]*)/g;
+function extractCssClassesRegex(lines, filePath, isModule, classes, seen) {
+	for (let i = 0; i < lines.length; i++) {
+		CSS_CLASS_RE.lastIndex = 0;
+		let match;
+		while ((match = CSS_CLASS_RE.exec(lines[i])) !== null) if (!seen.has(match[1])) {
+			seen.add(match[1]);
+			classes.push({
+				file_path: filePath,
+				name: match[1],
+				is_module: isModule ? 1 : 0,
+				line_number: i + 1
+			});
+		}
+	}
+}
+const KEYFRAMES_RE = /@keyframes\s+([\w-]+)/g;
+function extractCssKeyframesRegex(lines, filePath, keyframes) {
+	for (let i = 0; i < lines.length; i++) {
+		KEYFRAMES_RE.lastIndex = 0;
+		const match = KEYFRAMES_RE.exec(lines[i]);
+		if (match) keyframes.push({
+			file_path: filePath,
+			name: match[1],
+			line_number: i + 1
+		});
+	}
+}
+const IMPORT_RE = /@import\s+(?:url\()?['"]([^'"]+)['"]\)?/g;
+function extractImportSources(source, importSources) {
+	let match;
+	IMPORT_RE.lastIndex = 0;
+	while ((match = IMPORT_RE.exec(source)) !== null) importSources.push(match[1]);
+}
+//#endregion
+//#region src/hash.ts
+/**
+* Stable content fingerprint for incremental indexing.
+* Same algorithm on Bun and Node (unlike Bun.hash).
+*/
+function hashContent(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+//#endregion
+//#region src/parser.ts
+/**
+* Compute line number from byte offset.
+* Build a line-start-offsets array once, then binary search.
+*/
+function buildLineMap(source) {
+	const offsets = [0];
+	for (let i = 0; i < source.length; i++) if (source.charCodeAt(i) === 10) offsets.push(i + 1);
+	return offsets;
+}
+function offsetToLine(lineMap, offset) {
+	let lo = 0;
+	let hi = lineMap.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		if (lineMap[mid] <= offset) lo = mid;
+		else hi = mid - 1;
+	}
+	return lo + 1;
+}
+function extractFileData(filePath, source, relPath) {
+	const ext = extname(filePath).toLowerCase();
+	const lang = ext === ".tsx" ? "tsx" : ext === ".jsx" ? "jsx" : ext === ".ts" || ext === ".mts" || ext === ".cts" ? "ts" : "js";
+	const isTsx = ext === ".tsx" || ext === ".jsx";
+	const result = parseSync(filePath, source, {
+		lang,
+		preserveParens: false
+	});
+	const lineMap = buildLineMap(source);
+	const mod = result.module;
+	const symbols = [];
+	const imports = [];
+	const exports = [];
+	const components = [];
+	const markers = [];
+	const exportedNames = /* @__PURE__ */ new Set();
+	const defaultExportedNames = /* @__PURE__ */ new Set();
+	for (const exp of mod.staticExports) for (const entry of exp.entries) {
+		const exportName = entry.exportName;
+		if (exportName.kind === "Default") {
+			const localName = entry.localName;
+			if (localName.name) defaultExportedNames.add(localName.name);
+			defaultExportedNames.add("default");
+		} else if (exportName.kind === "Name" && exportName.name) exportedNames.add(exportName.name);
+		exports.push(exportEntryToRow(relPath, entry));
+	}
+	for (const imp of mod.staticImports) imports.push(staticImportToRow(relPath, imp, lineMap));
+	const hookCalls = /* @__PURE__ */ new Map();
+	let currentFunctionScope = null;
+	new Visitor({
+		FunctionDeclaration(node) {
+			const name = node.id?.name;
+			if (!name) return;
+			const lineStart = offsetToLine(lineMap, node.start);
+			const lineEnd = offsetToLine(lineMap, node.end);
+			const isExported = exportedNames.has(name) || defaultExportedNames.has(name);
+			const isDefault = defaultExportedNames.has(name);
+			symbols.push({
+				file_path: relPath,
+				name,
+				kind: "function",
+				line_start: lineStart,
+				line_end: lineEnd,
+				signature: buildFunctionSignature(name, node),
+				is_exported: isExported ? 1 : 0,
+				is_default_export: isDefault ? 1 : 0
+			});
+			if (isTsx && /^[A-Z]/.test(name)) {
+				currentFunctionScope = name;
+				hookCalls.set(name, /* @__PURE__ */ new Set());
+			}
+		},
+		"FunctionDeclaration:exit"(node) {
+			const name = node.id?.name;
+			if (name && currentFunctionScope === name) {
+				maybeAddComponent(name, node, false);
+				currentFunctionScope = null;
+			}
+		},
+		VariableDeclaration(node) {
+			for (const decl of node.declarations) {
+				const name = decl.id?.name;
+				if (!name) continue;
+				const init = decl.init;
+				const lineStart = offsetToLine(lineMap, node.start);
+				const lineEnd = offsetToLine(lineMap, node.end);
+				const isExported = exportedNames.has(name) || defaultExportedNames.has(name);
+				const isDefault = defaultExportedNames.has(name);
+				const isArrowOrFn = init?.type === "ArrowFunctionExpression" || init?.type === "FunctionExpression";
+				symbols.push({
+					file_path: relPath,
+					name,
+					kind: isArrowOrFn ? "function" : "const",
+					line_start: lineStart,
+					line_end: lineEnd,
+					signature: isArrowOrFn ? buildFunctionSignature(name, init) : `const ${name}`,
+					is_exported: isExported ? 1 : 0,
+					is_default_export: isDefault ? 1 : 0
+				});
+				if (isTsx && /^[A-Z]/.test(name) && isArrowOrFn) {
+					currentFunctionScope = name;
+					hookCalls.set(name, /* @__PURE__ */ new Set());
+				}
+			}
+		},
+		"VariableDeclaration:exit"(node) {
+			for (const decl of node.declarations) {
+				const name = decl.id?.name;
+				if (name && currentFunctionScope === name) {
+					maybeAddComponent(name, decl.init, true);
+					currentFunctionScope = null;
+				}
+			}
+		},
+		TSTypeAliasDeclaration(node) {
+			const name = node.id?.name;
+			if (!name) return;
+			const isExported = exportedNames.has(name);
+			symbols.push({
+				file_path: relPath,
+				name,
+				kind: "type",
+				line_start: offsetToLine(lineMap, node.start),
+				line_end: offsetToLine(lineMap, node.end),
+				signature: `type ${name}`,
+				is_exported: isExported ? 1 : 0,
+				is_default_export: 0
+			});
+		},
+		TSInterfaceDeclaration(node) {
+			const name = node.id?.name;
+			if (!name) return;
+			const isExported = exportedNames.has(name);
+			symbols.push({
+				file_path: relPath,
+				name,
+				kind: "interface",
+				line_start: offsetToLine(lineMap, node.start),
+				line_end: offsetToLine(lineMap, node.end),
+				signature: `interface ${name}`,
+				is_exported: isExported ? 1 : 0,
+				is_default_export: 0
+			});
+		},
+		TSEnumDeclaration(node) {
+			const name = node.id?.name;
+			if (!name) return;
+			const isExported = exportedNames.has(name);
+			symbols.push({
+				file_path: relPath,
+				name,
+				kind: "enum",
+				line_start: offsetToLine(lineMap, node.start),
+				line_end: offsetToLine(lineMap, node.end),
+				signature: `enum ${name}`,
+				is_exported: isExported ? 1 : 0,
+				is_default_export: 0
+			});
+		},
+		ClassDeclaration(node) {
+			const name = node.id?.name;
+			if (!name) return;
+			const isExported = exportedNames.has(name) || defaultExportedNames.has(name);
+			symbols.push({
+				file_path: relPath,
+				name,
+				kind: "class",
+				line_start: offsetToLine(lineMap, node.start),
+				line_end: offsetToLine(lineMap, node.end),
+				signature: `class ${name}`,
+				is_exported: isExported ? 1 : 0,
+				is_default_export: defaultExportedNames.has(name) ? 1 : 0
+			});
+		},
+		CallExpression(node) {
+			if (!currentFunctionScope) return;
+			const callee = node.callee;
+			if (callee?.type === "Identifier" && /^use[A-Z]/.test(callee.name)) hookCalls.get(currentFunctionScope)?.add(callee.name);
+		}
+	}).visit(result.program);
+	markers.push(...extractMarkers(source, relPath));
+	function maybeAddComponent(name, node, _isArrow) {
+		if (!isTsx || !/^[A-Z]/.test(name)) return;
+		const hooks = hookCalls.get(name);
+		const isDefault = defaultExportedNames.has(name);
+		let propsType = null;
+		const params = node?.params;
+		if (params?.length > 0) {
+			const firstParam = params[0];
+			if (firstParam.typeAnnotation?.typeAnnotation) {
+				const ta = firstParam.typeAnnotation.typeAnnotation;
+				if (ta.type === "TSTypeReference" && ta.typeName?.name) propsType = ta.typeName.name;
+			}
+		}
+		components.push({
+			file_path: relPath,
+			name,
+			props_type: propsType,
+			hooks_used: JSON.stringify(hooks ? [...hooks] : []),
+			is_default_export: isDefault ? 1 : 0
+		});
+	}
+	return {
+		symbols,
+		imports,
+		exports,
+		components,
+		markers
+	};
+}
+function staticImportToRow(filePath, imp, lineMap) {
+	const specifiers = [];
+	let isTypeOnly = true;
+	for (const entry of imp.entries) {
+		if (!entry.isType) isTypeOnly = false;
+		const importKind = entry.importName.kind;
+		if (importKind === "Default") specifiers.push(entry.localName.value);
+		else if (importKind === "NamespaceObject") specifiers.push(`* as ${entry.localName.value}`);
+		else if (importKind === "Name") {
+			const original = entry.importName.name;
+			const local = entry.localName.value;
+			specifiers.push(original === local ? original : `${original} as ${local}`);
+		}
+	}
+	if (imp.entries.length === 0) isTypeOnly = false;
+	return {
+		file_path: filePath,
+		source: imp.moduleRequest.value,
+		resolved_path: null,
+		specifiers: JSON.stringify(specifiers),
+		is_type_only: isTypeOnly ? 1 : 0,
+		line_number: offsetToLine(lineMap, imp.start)
+	};
+}
+function exportEntryToRow(filePath, entry) {
+	const exportName = entry.exportName;
+	const isDefault = exportName.kind === "Default";
+	const name = isDefault ? "default" : exportName.name ?? entry.localName.name ?? "unknown";
+	let kind = "value";
+	if (entry.isType) kind = "type";
+	if (entry.moduleRequest) kind = "re-export";
+	return {
+		file_path: filePath,
+		name,
+		kind,
+		is_default: isDefault ? 1 : 0,
+		re_export_source: entry.moduleRequest?.value ?? null
+	};
+}
+function buildFunctionSignature(name, node) {
+	const params = node?.params;
+	if (!params || params.length === 0) return `${name}()`;
+	return `${name}(${params.map((p) => p.name ?? p.left?.name ?? p.argument?.name ?? "...").join(", ")})`;
+}
+//#endregion
+export { LANG_MAP as a, extractMarkers as i, hashContent as n, extractCssData as r, extractFileData as t };

package/dist/run-index-DQD5afqQ.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+import { _ as createSchema, b as setMeta, c as deleteFilesFromIndex, d as indexFiles, l as getChangedFiles, m as targetedReindex, o as VALID_EXTENSIONS, s as collectFiles, u as getCurrentCommit, v as getAllFileHashes } from "./config-CsPgQWSX.mjs";
+import { extname } from "node:path";
+//#region src/application/run-index.ts
+function emptyStats() {
+	return {
+		files: 0,
+		symbols: 0,
+		imports: 0,
+		exports: 0,
+		components: 0,
+		dependencies: 0,
+		markers: 0,
+		css_vars: 0,
+		css_classes: 0,
+		css_keyframes: 0
+	};
+}
+/**
+* Core indexing pipeline (CLI and `Codemap#index`).
+*
+* @param db - Open database; caller owns the connection lifecycle.
+* @param options - Index mode, optional targeted paths, and logging.
+* @returns Row counts and timing; see {@link IndexResult}.
+*
+* @remarks
+* Call `initCodemap()` and `configureResolver()` for this project before invoking (same as CLI bootstrap).
+*/
+async function runCodemapIndex(db, options = {}) {
+	const quiet = options.quiet ?? false;
+	const mode = options.mode ?? "incremental";
+	if (mode === "full") {
+		if (!quiet) console.log("  Full rebuild requested...");
+		const run = await indexFiles(db, collectFiles(), true, void 0, { quiet });
+		return {
+			mode: "full",
+			indexed: run.indexed,
+			skipped: run.skipped,
+			elapsedMs: run.elapsedMs,
+			stats: run.stats
+		};
+	}
+	if (mode === "files") {
+		const targetFiles = (options.files ?? []).filter((f) => {
+			const ext = extname(f);
+			return VALID_EXTENSIONS.has(ext);
+		});
+		if (targetFiles.length === 0) return {
+			mode: "files",
+			indexed: 0,
+			skipped: 0,
+			elapsedMs: 0,
+			stats: emptyStats(),
+			idle: true
+		};
+		const run = await targetedReindex(db, targetFiles, quiet);
+		return {
+			mode: "files",
+			indexed: run.indexed,
+			skipped: run.skipped,
+			elapsedMs: run.elapsedMs,
+			stats: run.stats
+		};
+	}
+	createSchema(db);
+	const diff = getChangedFiles(db);
+	if (diff) {
+		if (!quiet) console.log(`  Incremental: ${diff.changed.length} changed, ${diff.deleted.length} deleted`);
+		deleteFilesFromIndex(db, diff.deleted, quiet);
+		if (diff.changed.length > 0) {
+			const indexedPaths = new Set(getAllFileHashes(db).keys());
+			for (const f of diff.changed) indexedPaths.add(f);
+			const run = await indexFiles(db, diff.changed, false, indexedPaths, { quiet });
+			return {
+				mode: "incremental",
+				indexed: run.indexed,
+				skipped: run.skipped,
+				elapsedMs: run.elapsedMs,
+				stats: run.stats
+			};
+		}
+		if (diff.deleted.length > 0) {
+			setMeta(db, "last_indexed_commit", getCurrentCommit());
+			if (!quiet) console.log("  Index updated (deletions only)");
+			return {
+				mode: "incremental",
+				indexed: 0,
+				skipped: 0,
+				elapsedMs: 0,
+				stats: fetchStats(db),
+				idle: true
+			};
+		}
+		if (!quiet) console.log("  Index is up to date");
+		return {
+			mode: "incremental",
+			indexed: 0,
+			skipped: 0,
+			elapsedMs: 0,
+			stats: fetchStats(db),
+			idle: true
+		};
+	}
+	if (!quiet) console.log("  No previous index or incompatible history, doing full rebuild...");
+	const run = await indexFiles(db, collectFiles(), true, void 0, { quiet });
+	return {
+		mode: "full",
+		indexed: run.indexed,
+		skipped: run.skipped,
+		elapsedMs: run.elapsedMs,
+		stats: run.stats
+	};
+}
+function fetchStats(db) {
+	return db.query(`SELECT
+        (SELECT COUNT(*) FROM files) as files,
+        (SELECT COUNT(*) FROM symbols) as symbols,
+        (SELECT COUNT(*) FROM imports) as imports,
+        (SELECT COUNT(*) FROM exports) as exports,
+        (SELECT COUNT(*) FROM components) as components,
+        (SELECT COUNT(*) FROM dependencies) as dependencies,
+        (SELECT COUNT(*) FROM markers) as markers,
+        (SELECT COUNT(*) FROM css_variables) as css_vars,
+        (SELECT COUNT(*) FROM css_classes) as css_classes,
+        (SELECT COUNT(*) FROM css_keyframes) as css_keyframes`).get();
+}
+//#endregion
+export { runCodemapIndex as t };

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@stainless-code/codemap",
+  "version": "0.1.0",
+  "description": "Query your codebase — structural SQLite index for AI agents",
+  "keywords": [
+    "agents",
+    "ai",
+    "codebase",
+    "dependencies",
+    "imports",
+    "index",
+    "sqlite",
+    "symbols"
+  ],
+  "homepage": "https://github.com/stainless-code/codemap#readme",
+  "bugs": {
+    "url": "https://github.com/stainless-code/codemap/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stainless-code/codemap.git"
+  },
+  "bin": {
+    "codemap": "./dist/index.mjs"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "dist",
+    "templates"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "benchmark": "bun src/benchmark.ts",
+    "build": "tsdown",
+    "changeset": "changeset",
+    "check": "bun run build && bun run --parallel format:check lint:ci test typecheck",
+    "dev": "bun src/index.ts",
+    "fix": "bun run lint:fix && bun run format",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check --no-error-on-unmatched-pattern",
+    "lint": "oxlint",
+    "lint-staged": "lint-staged",
+    "lint:ci": "oxlint --quiet",
+    "lint:fix": "oxlint --fix",
+    "pack": "bun run build && npm pack",
+    "prepare": "husky || true",
+    "prepublishOnly": "bun run build",
+    "release": "changeset publish",
+    "test": "bun test",
+    "test:ci": "bun run test:coverage",
+    "test:coverage": "bun test --coverage",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.8.0",
+    "fast-glob": "^3.3.3",
+    "lightningcss": "^1.32.0",
+    "oxc-parser": "^0.123.0",
+    "oxc-resolver": "^11.19.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.6.0",
+    "@changesets/cli": "^2.30.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bun": "^1.3.11",
+    "@types/node": "^25.5.2",
+    "@typescript/native-preview": "^7.0.0-dev.20260406.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "oxfmt": "^0.43.0",
+    "oxlint": "^1.58.0",
+    "tsdown": "^0.21.7",
+    "typescript": "^6.0.2"
+  },
+  "engines": {
+    "bun": ">=1.0.0",
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "contributing": ".github/CONTRIBUTING.md"
+}

package/templates/agents/README.md

@@ -0,0 +1,5 @@
+# Bundled agent templates
+
+These files are **copies** of the upstream [`.agents/`](../../.agents/) rules and skills shipped with `@stainless-code/codemap` for `codemap agents init`.
+
+After running the command, **edit** `.agents/` in your project (paths, SQL, team conventions). Treat updates here as a reference when refreshing your copy.