nostics 0.0.0 → 0.0.4

package/dist/unplugin.mjs

@@ -0,0 +1,207 @@
+import { createUnplugin } from "unplugin";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import MagicString from "magic-string";
+import { parseSync } from "oxc-parser";
+//#region src/code-transform/transform.ts
+/**
+* Transforms code that imports from `nostics`:
+* - Adds `\/*#__PURE__*\/` to `defineDiagnostics()` and `createLogger()` call expressions
+* - Prepends `process.env.NODE_ENV !== 'production' &&` to expression statements using logger variables
+*
+* Also handles cross-file patterns: if a file imports a variable that was
+* created from `createLogger()` or `defineDiagnostics()` in another file,
+* the usage is tracked and wrapped.
+*/
+function transform(code, id, options, trackedExportsMap) {
+	const packageName = options?.packageName ?? "nostics";
+	const ast = parseSync(id, code).program;
+	const importedNames = /* @__PURE__ */ new Map();
+	for (const node of ast.body) if (node.type === "ImportDeclaration" && node.source.value === packageName) {
+		for (const spec of node.specifiers) if (spec.type === "ImportSpecifier") {
+			const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+			importedNames.set(spec.local.name, importedName);
+		}
+	}
+	const crossFileTracked = /* @__PURE__ */ new Set();
+	if (trackedExportsMap) {
+		for (const node of ast.body) if (node.type === "ImportDeclaration" && node.source.value !== packageName) {
+			const source = node.source.value;
+			if (!source.startsWith(".")) continue;
+			const resolvedPath = resolveModulePath(source, id);
+			if (!resolvedPath) continue;
+			if (!trackedExportsMap.has(resolvedPath)) analyzeModule(resolvedPath, packageName, trackedExportsMap);
+			const trackedNames = trackedExportsMap.get(resolvedPath);
+			if (trackedNames) {
+				for (const spec of node.specifiers) if (spec.type === "ImportSpecifier") {
+					const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+					if (trackedNames.has(importedName)) crossFileTracked.add(spec.local.name);
+				}
+			}
+		}
+	}
+	if (importedNames.size === 0 && crossFileTracked.size === 0) return void 0;
+	const s = new MagicString(code);
+	const trackedVars = new Set(crossFileTracked);
+	walkStatements(ast.body, s, importedNames, trackedVars);
+	if (!s.hasChanged()) return void 0;
+	if (trackedExportsMap) {
+		const exportedTracked = /* @__PURE__ */ new Set();
+		for (const node of ast.body) if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+			for (const decl of node.declaration.declarations) if (decl.id?.type === "Identifier" && trackedVars.has(decl.id.name)) exportedTracked.add(decl.id.name);
+		}
+		if (exportedTracked.size > 0) trackedExportsMap.set(id, exportedTracked);
+	}
+	return {
+		code: s.toString(),
+		map: s.generateMap({ hires: "boundary" })
+	};
+}
+const CONDITION = "process.env.NODE_ENV !== 'production'";
+/**
+* Check if an expression has lower precedence than `&&` and needs inner parens
+* when used as the right-hand side of `guard && expr`.
+*/
+function expressionNeedsParens(node) {
+	if (node.type === "ConditionalExpression") return true;
+	if (node.type === "LogicalExpression" && (node.operator === "||" || node.operator === "??")) return true;
+	if (node.type === "SequenceExpression") return true;
+	if (node.type === "AssignmentExpression") return true;
+	return false;
+}
+const EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs"
+];
+function resolveModulePath(source, importer) {
+	const base = join(dirname(importer), source);
+	if (existsSync(base)) return base;
+	for (const ext of EXTENSIONS) {
+		const candidate = base + ext;
+		if (existsSync(candidate)) return candidate;
+	}
+	for (const ext of EXTENSIONS) {
+		const candidate = join(base, `index${ext}`);
+		if (existsSync(candidate)) return candidate;
+	}
+}
+/**
+* Analyze a module to find exported variables derived from nostics calls.
+* Results are cached in trackedExportsMap.
+*/
+function analyzeModule(filePath, packageName, trackedExportsMap) {
+	trackedExportsMap.set(filePath, /* @__PURE__ */ new Set());
+	let source;
+	try {
+		source = readFileSync(filePath, "utf-8");
+	} catch {
+		return;
+	}
+	if (!source.includes(packageName)) return;
+	const ast = parseSync(filePath, source).program;
+	const importedNames = /* @__PURE__ */ new Set();
+	for (const node of ast.body) if (node.type === "ImportDeclaration" && node.source.value === packageName) {
+		for (const spec of node.specifiers) if (spec.type === "ImportSpecifier") importedNames.add(spec.local.name);
+	}
+	if (importedNames.size === 0) return;
+	const trackedExports = /* @__PURE__ */ new Set();
+	for (const node of ast.body) if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+		for (const decl of node.declaration.declarations) if (decl.init?.type === "CallExpression" && decl.init.callee?.type === "Identifier" && importedNames.has(decl.init.callee.name) && decl.id?.type === "Identifier") trackedExports.add(decl.id.name);
+	}
+	if (trackedExports.size > 0) trackedExportsMap.set(filePath, trackedExports);
+}
+function walkStatements(body, s, importedNames, trackedVars) {
+	for (const stmt of body) {
+		if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations) if (decl.init?.type === "CallExpression" && decl.init.callee?.type === "Identifier" && importedNames.has(decl.init.callee.name) && decl.id?.type === "Identifier") {
+				trackedVars.add(decl.id.name);
+				s.appendLeft(decl.init.start, "/*#__PURE__*/ ");
+			}
+		}
+		if (stmt.type === "ExpressionStatement") {
+			if (expressionUsesTrackedVar(stmt.expression, trackedVars)) if (expressionNeedsParens(stmt.expression)) {
+				s.appendLeft(stmt.expression.start, `${CONDITION} && (`);
+				s.appendRight(stmt.expression.end, `)`);
+			} else s.appendLeft(stmt.expression.start, `${CONDITION} && `);
+		}
+		if (stmt.type === "BlockStatement" || stmt.type === "Program") walkStatements(stmt.body, s, importedNames, trackedVars);
+		if (stmt.type === "IfStatement") {
+			if (stmt.consequent?.type === "BlockStatement") walkStatements(stmt.consequent.body, s, importedNames, trackedVars);
+			if (stmt.alternate?.type === "BlockStatement") walkStatements(stmt.alternate.body, s, importedNames, trackedVars);
+		}
+		if (stmt.type === "ForStatement" || stmt.type === "WhileStatement" || stmt.type === "DoWhileStatement") {
+			if (stmt.body?.type === "BlockStatement") walkStatements(stmt.body.body, s, importedNames, trackedVars);
+		}
+		if (stmt.type === "FunctionDeclaration" || stmt.type === "ArrowFunctionExpression") {
+			if (stmt.body?.type === "BlockStatement") walkStatements(stmt.body.body, s, importedNames, trackedVars);
+		}
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) walkStatements([stmt.declaration], s, importedNames, trackedVars);
+	}
+}
+/**
+* Check if an expression references a tracked variable as the root of a member/call chain.
+*/
+function expressionUsesTrackedVar(node, trackedVars) {
+	if (!node) return false;
+	if (node.type === "Identifier") return trackedVars.has(node.name);
+	if (node.type === "MemberExpression") return expressionUsesTrackedVar(node.object, trackedVars);
+	if (node.type === "CallExpression") return expressionUsesTrackedVar(node.callee, trackedVars);
+	if (node.type === "LogicalExpression") return expressionUsesTrackedVar(node.left, trackedVars) || expressionUsesTrackedVar(node.right, trackedVars);
+	if (node.type === "ConditionalExpression") return expressionUsesTrackedVar(node.consequent, trackedVars) || expressionUsesTrackedVar(node.alternate, trackedVars);
+	if (node.type === "UnaryExpression") return expressionUsesTrackedVar(node.argument, trackedVars);
+	if (node.type === "AwaitExpression") return expressionUsesTrackedVar(node.argument, trackedVars);
+	if (node.type === "SequenceExpression") return node.expressions.some((expr) => expressionUsesTrackedVar(expr, trackedVars));
+	if (node.type === "ParenthesizedExpression") return expressionUsesTrackedVar(node.expression, trackedVars);
+	return false;
+}
+//#endregion
+//#region src/code-transform/server-plugin.ts
+const logsSDKServer = createUnplugin((options) => {
+	const logFile = options?.logFile ?? ".nostics.log";
+	return {
+		name: "nostics-server",
+		enforce: "pre",
+		vite: { configureServer(server) {
+			server.ws.on("nostics:report", (data) => {
+				try {
+					appendFileSync(logFile, `${JSON.stringify(data)}\n`);
+				} catch (err) {
+					console.error(`[nostics]: Failed to write log to "${logFile}":`, err);
+				}
+			});
+		} }
+	};
+});
+//#endregion
+//#region src/code-transform/unplugin.ts
+const JS_EXTENSIONS_RE = /\.[jt]sx?$/;
+const NODE_MODULES_RE = /\/node_modules\//;
+const unpluginFactory = (options) => {
+	const trackedExportsMap = /* @__PURE__ */ new Map();
+	return {
+		name: "nostics",
+		transform: {
+			filter: { id: {
+				include: JS_EXTENSIONS_RE,
+				exclude: NODE_MODULES_RE
+			} },
+			handler(code, id) {
+				const result = transform(code, id, options, trackedExportsMap);
+				if (!result) return;
+				return {
+					code: result.code,
+					map: result.map
+				};
+			}
+		}
+	};
+};
+const logsSDK = /* @__PURE__ */ createUnplugin(unpluginFactory);
+//#endregion
+export { logsSDK as default, logsSDK, logsSDKServer };
+
+//# sourceMappingURL=unplugin.mjs.map

package/dist/unplugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unplugin.mjs","names":[],"sources":["../src/code-transform/transform.ts","../src/code-transform/server-plugin.ts","../src/code-transform/unplugin.ts"],"sourcesContent":["import { existsSync, readFileSync } from 'node:fs'\nimport { dirname, join } from 'node:path'\nimport MagicString from 'magic-string'\nimport { parseSync } from 'oxc-parser'\n\nexport interface TransformResult {\n  code: string\n  map: ReturnType<MagicString['generateMap']>\n}\n\nexport interface TransformOptions {\n  /**\n   * The package name to detect imports from.\n   * @default 'nostics'\n   */\n  packageName?: string\n}\n\n/**\n * Cross-file state: maps file paths to sets of exported variable names\n * that are derived from nostics function calls (createLogger, defineDiagnostics, etc.)\n */\nexport type TrackedExportsMap = Map<string, Set<string>>\n\n/**\n * Transforms code that imports from `nostics`:\n * - Adds `\\/*#__PURE__*\\/` to `defineDiagnostics()` and `createLogger()` call expressions\n * - Prepends `process.env.NODE_ENV !== 'production' &&` to expression statements using logger variables\n *\n * Also handles cross-file patterns: if a file imports a variable that was\n * created from `createLogger()` or `defineDiagnostics()` in another file,\n * the usage is tracked and wrapped.\n */\nexport function transform(\n  code: string,\n  id: string,\n  options?: TransformOptions,\n  trackedExportsMap?: TrackedExportsMap,\n): TransformResult | undefined {\n  const packageName = options?.packageName ?? 'nostics'\n\n  const result = parseSync(id, code)\n  const ast = result.program\n\n  // Step 1: Find direct imports from the package\n  const importedNames = new Map<string, string>() // localName -> importedName\n  for (const node of ast.body) {\n    if (node.type === 'ImportDeclaration' && node.source.value === packageName) {\n      for (const spec of node.specifiers) {\n        if (spec.type === 'ImportSpecifier') {\n          const importedName = spec.imported.type === 'Identifier' ? spec.imported.name : spec.imported.value\n          importedNames.set(spec.local.name, importedName)\n        }\n      }\n    }\n  }\n\n  // Step 2: Find cross-file tracked imports\n  const crossFileTracked = new Set<string>()\n  if (trackedExportsMap) {\n    for (const node of ast.body) {\n      if (node.type === 'ImportDeclaration' && node.source.value !== packageName) {\n        const source = node.source.value as string\n        // Only resolve relative imports\n        if (!source.startsWith('.'))\n          continue\n\n        const resolvedPath = resolveModulePath(source, id)\n        if (!resolvedPath)\n          continue\n\n        // Analyze the imported module if not already cached\n        if (!trackedExportsMap.has(resolvedPath)) {\n          analyzeModule(resolvedPath, packageName, trackedExportsMap)\n        }\n\n        const trackedNames = trackedExportsMap.get(resolvedPath)\n        if (trackedNames) {\n          for (const spec of node.specifiers) {\n            if (spec.type === 'ImportSpecifier') {\n              const importedName = spec.imported.type === 'Identifier' ? spec.imported.name : spec.imported.value\n              if (trackedNames.has(importedName)) {\n                crossFileTracked.add(spec.local.name)\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  if (importedNames.size === 0 && crossFileTracked.size === 0)\n    return undefined\n\n  const s = new MagicString(code)\n  const trackedVars = new Set<string>(crossFileTracked)\n\n  // Step 3: Walk all statements recursively\n  walkStatements(ast.body, s, importedNames, trackedVars)\n\n  if (!s.hasChanged())\n    return undefined\n\n  // Step 4: Record exported tracked vars for cross-file tracking\n  if (trackedExportsMap) {\n    const exportedTracked = new Set<string>()\n    for (const node of ast.body) {\n      if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {\n        for (const decl of node.declaration.declarations) {\n          if (decl.id?.type === 'Identifier' && trackedVars.has(decl.id.name)) {\n            exportedTracked.add(decl.id.name)\n          }\n        }\n      }\n    }\n    if (exportedTracked.size > 0) {\n      trackedExportsMap.set(id, exportedTracked)\n    }\n  }\n\n  return {\n    code: s.toString(),\n    map: s.generateMap({ hires: 'boundary' }),\n  }\n}\n\nconst CONDITION = 'process.env.NODE_ENV !== \\'production\\''\n\n/**\n * Check if an expression has lower precedence than `&&` and needs inner parens\n * when used as the right-hand side of `guard && expr`.\n */\nfunction expressionNeedsParens(node: any): boolean {\n  if (node.type === 'ConditionalExpression')\n    return true\n  if (node.type === 'LogicalExpression' && (node.operator === '||' || node.operator === '??'))\n    return true\n  if (node.type === 'SequenceExpression')\n    return true\n  if (node.type === 'AssignmentExpression')\n    return true\n  return false\n}\n\nconst EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs']\n\nfunction resolveModulePath(source: string, importer: string): string | undefined {\n  const dir = dirname(importer)\n  const base = join(dir, source)\n\n  // Try exact path (for imports with extension)\n  if (existsSync(base))\n    return base\n\n  // Try with extensions\n  for (const ext of EXTENSIONS) {\n    const candidate = base + ext\n    if (existsSync(candidate))\n      return candidate\n  }\n\n  // Try index files\n  for (const ext of EXTENSIONS) {\n    const candidate = join(base, `index${ext}`)\n    if (existsSync(candidate))\n      return candidate\n  }\n\n  return undefined\n}\n\n/**\n * Analyze a module to find exported variables derived from nostics calls.\n * Results are cached in trackedExportsMap.\n */\nfunction analyzeModule(filePath: string, packageName: string, trackedExportsMap: TrackedExportsMap): void {\n  // Mark as analyzed (even if no tracked exports) to avoid re-analysis\n  trackedExportsMap.set(filePath, new Set())\n\n  let source: string\n  try {\n    source = readFileSync(filePath, 'utf-8')\n  }\n  catch {\n    return\n  }\n\n  if (!source.includes(packageName))\n    return\n\n  const result = parseSync(filePath, source)\n  const ast = result.program\n\n  // Find imports from the package\n  const importedNames = new Set<string>()\n  for (const node of ast.body) {\n    if (node.type === 'ImportDeclaration' && node.source.value === packageName) {\n      for (const spec of node.specifiers) {\n        if (spec.type === 'ImportSpecifier') {\n          importedNames.add(spec.local.name)\n        }\n      }\n    }\n  }\n\n  if (importedNames.size === 0)\n    return\n\n  // Find exported variables assigned from imported function calls\n  const trackedExports = new Set<string>()\n  for (const node of ast.body) {\n    if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {\n      for (const decl of node.declaration.declarations) {\n        if (\n          decl.init?.type === 'CallExpression'\n          && decl.init.callee?.type === 'Identifier'\n          && importedNames.has(decl.init.callee.name)\n          && decl.id?.type === 'Identifier'\n        ) {\n          trackedExports.add(decl.id.name)\n        }\n      }\n    }\n  }\n\n  if (trackedExports.size > 0) {\n    trackedExportsMap.set(filePath, trackedExports)\n  }\n}\n\nfunction walkStatements(\n  body: any[],\n  s: MagicString,\n  importedNames: Map<string, string>,\n  trackedVars: Set<string>,\n): void {\n  for (const stmt of body) {\n    // Variable declaration: const x = importedFn(...)\n    if (stmt.type === 'VariableDeclaration') {\n      for (const decl of stmt.declarations) {\n        if (\n          decl.init?.type === 'CallExpression'\n          && decl.init.callee?.type === 'Identifier'\n          && importedNames.has(decl.init.callee.name)\n          && decl.id?.type === 'Identifier'\n        ) {\n          // Track the variable\n          trackedVars.add(decl.id.name)\n          // Add /*#__PURE__*/ before the call expression\n          s.appendLeft(decl.init.start, '/*#__PURE__*/ ')\n        }\n      }\n    }\n\n    // Expression statement using a tracked variable\n    if (stmt.type === 'ExpressionStatement') {\n      if (expressionUsesTrackedVar(stmt.expression, trackedVars)) {\n        const needsParens = expressionNeedsParens(stmt.expression)\n        if (needsParens) {\n          s.appendLeft(stmt.expression.start, `${CONDITION} && (`)\n          s.appendRight(stmt.expression.end, `)`)\n        }\n        else {\n          s.appendLeft(stmt.expression.start, `${CONDITION} && `)\n        }\n      }\n    }\n\n    // Recurse into block-containing statements\n    if (stmt.type === 'BlockStatement' || stmt.type === 'Program') {\n      walkStatements(stmt.body, s, importedNames, trackedVars)\n    }\n    if (stmt.type === 'IfStatement') {\n      if (stmt.consequent?.type === 'BlockStatement') {\n        walkStatements(stmt.consequent.body, s, importedNames, trackedVars)\n      }\n      if (stmt.alternate?.type === 'BlockStatement') {\n        walkStatements(stmt.alternate.body, s, importedNames, trackedVars)\n      }\n    }\n    if (stmt.type === 'ForStatement' || stmt.type === 'WhileStatement' || stmt.type === 'DoWhileStatement') {\n      if (stmt.body?.type === 'BlockStatement') {\n        walkStatements(stmt.body.body, s, importedNames, trackedVars)\n      }\n    }\n    if (stmt.type === 'FunctionDeclaration' || stmt.type === 'ArrowFunctionExpression') {\n      if (stmt.body?.type === 'BlockStatement') {\n        walkStatements(stmt.body.body, s, importedNames, trackedVars)\n      }\n    }\n    // Handle ExportNamedDeclaration wrapping a VariableDeclaration\n    if (stmt.type === 'ExportNamedDeclaration' && stmt.declaration) {\n      walkStatements([stmt.declaration], s, importedNames, trackedVars)\n    }\n  }\n}\n\n/**\n * Check if an expression references a tracked variable as the root of a member/call chain.\n */\nfunction expressionUsesTrackedVar(node: any, trackedVars: Set<string>): boolean {\n  if (!node)\n    return false\n\n  // Direct identifier reference\n  if (node.type === 'Identifier') {\n    return trackedVars.has(node.name)\n  }\n\n  // Member expression: check the object (root of the chain)\n  if (node.type === 'MemberExpression') {\n    return expressionUsesTrackedVar(node.object, trackedVars)\n  }\n\n  // Call expression: check the callee\n  if (node.type === 'CallExpression') {\n    return expressionUsesTrackedVar(node.callee, trackedVars)\n  }\n\n  // Logical expression: check either side\n  if (node.type === 'LogicalExpression') {\n    return expressionUsesTrackedVar(node.left, trackedVars)\n      || expressionUsesTrackedVar(node.right, trackedVars)\n  }\n\n  // Conditional (ternary): check consequent or alternate\n  if (node.type === 'ConditionalExpression') {\n    return expressionUsesTrackedVar(node.consequent, trackedVars)\n      || expressionUsesTrackedVar(node.alternate, trackedVars)\n  }\n\n  // Unary expression: check argument\n  if (node.type === 'UnaryExpression') {\n    return expressionUsesTrackedVar(node.argument, trackedVars)\n  }\n\n  // Await expression: check argument\n  if (node.type === 'AwaitExpression') {\n    return expressionUsesTrackedVar(node.argument, trackedVars)\n  }\n\n  // Sequence expression: check any element\n  if (node.type === 'SequenceExpression') {\n    return node.expressions.some((expr: any) => expressionUsesTrackedVar(expr, trackedVars))\n  }\n\n  // Parenthesized expression: unwrap\n  if (node.type === 'ParenthesizedExpression') {\n    return expressionUsesTrackedVar(node.expression, trackedVars)\n  }\n\n  return false\n}\n","import type { UnpluginInstance } from 'unplugin'\nimport { appendFileSync } from 'node:fs'\nimport { createUnplugin } from 'unplugin'\n\nexport interface LogsSdkServerOptions {\n  /**\n   * Path to the log file.\n   * @default '.nostics.log'\n   */\n  logFile?: string\n}\n\nexport const logsSDKServer: UnpluginInstance<LogsSdkServerOptions | undefined> = createUnplugin((options) => {\n  const logFile = options?.logFile ?? '.nostics.log'\n\n  return {\n    name: 'nostics-server',\n    enforce: 'pre',\n\n    vite: {\n      configureServer(server) {\n        server.ws.on('nostics:report', (data) => {\n          try {\n            // TODO: validate data shape\n            appendFileSync(logFile, `${JSON.stringify(data)}\\n`)\n          }\n          catch (err: unknown) {\n            console.error(`[nostics]: Failed to write log to \"${logFile}\":`, err)\n          }\n        })\n      },\n    },\n  }\n})\n","import type { UnpluginFactory, UnpluginInstance } from 'unplugin'\nimport type { TrackedExportsMap, TransformOptions } from './transform'\nimport { createUnplugin } from 'unplugin'\nimport { transform } from './transform'\n\nexport type LogsSdkPluginOptions = TransformOptions\n\nconst JS_EXTENSIONS_RE = /\\.[jt]sx?$/\nconst NODE_MODULES_RE = /\\/node_modules\\//\n\nconst unpluginFactory: UnpluginFactory<LogsSdkPluginOptions | undefined> = (options) => {\n  const trackedExportsMap: TrackedExportsMap = new Map()\n\n  return {\n    name: 'nostics',\n\n    transform: {\n      filter: {\n        id: {\n          include: JS_EXTENSIONS_RE,\n          exclude: NODE_MODULES_RE,\n        },\n      },\n      handler(code, id) {\n        const result = transform(code, id, options, trackedExportsMap)\n        if (!result)\n          return\n        return {\n          code: result.code,\n          map: result.map as any,\n        }\n      },\n    },\n  }\n}\n\nexport const logsSDK: UnpluginInstance<LogsSdkPluginOptions | undefined> = /* #__PURE__ */ createUnplugin<LogsSdkPluginOptions | undefined>(unpluginFactory)\nexport default logsSDK\n\nexport { logsSDKServer } from './server-plugin'\nexport type { LogsSdkServerOptions } from './server-plugin'\n"],"mappings":"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"}

package/package.json

@@ -1,11 +1,88 @@
 {
   "name": "nostics",
-  "version": "0.0.0",
-  "description": "Placeholder for nostics",
-  "main": "index.js",
-  "scripts": {},
+  "type": "module",
+  "version": "0.0.4",
+  "description": "Structured diagnostic code library",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/vercel-labs/nostics#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vercel-labs/nostics.git"
+  },
+  "bugs": "https://github.com/vercel-labs/nostics/issues",
   "keywords": [],
-  "author": "posva (https://www.npmjs.com/~posva)",
-  "license": "UNLICENSED",
-  "private": false
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./dev-reporter": "./dist/dev-reporter.mjs",
+    "./formatters/ansi": "./dist/formatters/ansi.mjs",
+    "./formatters/json": "./dist/formatters/json.mjs",
+    "./unplugin": "./dist/unplugin.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "peerDependencies": {
+    "magic-string": ">=0.30.0",
+    "oxc-parser": ">=0.50.0",
+    "unplugin": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "magic-string": {
+      "optional": true
+    },
+    "oxc-parser": {
+      "optional": true
+    },
+    "unplugin": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "magic-string": "^0.30.21",
+    "oxc-parser": "^0.124.0",
+    "unplugin": "^3.0.0"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^8.1.0",
+    "@antfu/ni": "^30.0.0",
+    "@antfu/utils": "^9.3.0",
+    "@posva/prompts": "^2.4.4",
+    "@types/node": "^25.5.2",
+    "@types/semver": "^7.7.1",
+    "bumpp": "^11.0.1",
+    "conventional-changelog": "^7.2.0",
+    "conventional-changelog-angular": "^8.3.1",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.2.0",
+    "lint-staged": "^16.4.0",
+    "publint": "^0.3.18",
+    "semver": "^7.7.4",
+    "simple-git-hooks": "^2.13.1",
+    "tsdown": "^0.21.7",
+    "tsnapi": "^0.1.1",
+    "typescript": "^6.0.2",
+    "vite": "^8.0.7",
+    "vitest": "^4.1.3",
+    "nostics": "0.0.4"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm i --frozen-lockfile --ignore-scripts --offline && npx lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "vitest",
+    "play": "pnpm -C playground run dev",
+    "lint": "eslint",
+    "release": "node scripts/release.ts",
+    "test": "pnpm run build && pnpm -r run build && tsc && eslint && vitest run",
+    "typecheck": "tsc"
+  }
 }

package/skills/add-diagnostic/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: add-diagnostic
+description: "Add a new diagnostic code following the defineDiagnostics() conventions from nostics"
+user-invocable: true
+allowed-tools: Read Grep Glob Edit Write
+---
+
+# Add a New Diagnostic Code
+
+## Step 1: Find the Target File
+
+Locate the file containing the `defineDiagnostics()` call where the new code should be added.
+
+Use Grep to search for `defineDiagnostics` across the project.
+
+## Step 2: Determine the Code Identifier
+
+Diagnostic codes follow the pattern `PREFIX_XNNNN`:
+
+- **PREFIX** — project/domain name in uppercase (e.g., `NUXT`, `MATH`, `I18N`)
+- **X** — category letter: `B` (build), `R` (runtime), `C` (config), `E` (error), `W` (warning), `D` (deprecation), `I` (info)
+- **NNNN** — numeric sequence
+
+Look at existing codes in the target file to determine the prefix, category, and next available number. Codes must never be reused once published.
+
+## Step 3: Add the Definition
+
+Add the new entry to the `codes` object inside `defineDiagnostics()`:
+
+```ts
+CODE_NAME: {
+  message: 'Static message.',
+  // OR with parameters:
+  message: (p: { paramName: string }) => `Template with ${p.paramName}.`,
+  fix: 'How to resolve the issue.',        // optional but recommended
+  why: 'Why this diagnostic was triggered.', // optional
+  hint: 'Additional guidance.',              // optional
+  level: 'error',                            // 'error' | 'warn' | 'suggestion' | 'deprecation'
+                                             // defaults to 'error' if omitted
+},
+```
+
+Rules:
+- `message` is the only required field
+- Parameters can appear in any template field (`message`, `fix`, `why`, `hint`) — TypeScript unions them all
+- Always provide `fix` when the solution is known
+- Set `level` explicitly if it's not `'error'`
+- Use typed arrow functions for parameterized templates: `(p: { key: Type }) => string`