@konvert7/klint 0.33.0 → 0.33.1

package/README.md

@@ -108,7 +108,7 @@ Rules give agents room to move quickly because the unsafe moves are blocked stru
 
 ```sh
 klint [--config <dir>] [--rules <file>] [--engine ts|rust|compare|auto] [--fix] [--json]
-klint install-skill [--agents <list>] [--symlink | --copy]
+klint install-skill [--agents <list>] [--symlink | --copy] [--force]
 ```
 
 | Flag | Description |
@@ -122,9 +122,45 @@ klint install-skill [--agents <list>] [--symlink | --copy]
 `klint install-skill` installs the bundled rule-authoring skill for agent environments:
 
 ```sh
-klint install-skill --agents claude,opencode,cursor,codex --copy
+klint install-skill
 ```
 
+The skill is embedded in the native engine, so this works from every distribution — the npm package, the PyPI wheel, the NuGet tool, and the standalone binary — not just Node projects.
+
+### Shared layout (default)
+
+By default the skill lives in exactly one place and every other agent directory points at it:
+
+```
+.agents/skills/klint-rules/         real skill + .klint-skill.json receipt
+.claude/skills/klint-rules  ->      ../../.agents/skills/klint-rules
+.cursor/skills/klint-rules  ->      ../../.agents/skills/klint-rules
+```
+
+`.agents/skills` is where opencode and Codex already read from, so it doubles as the hub. One source of truth means one file to diff, one receipt, and one warning when it drifts. The links are relative and stay inside the repo — nothing points into `node_modules`, so reinstalling dependencies can never break them.
+
+Pass `--copy` instead to give every agent directory its own independent copy and receipt.
+
+### Staleness and legacy links
+
+Each installed skill carries a `.klint-skill.json` receipt recording the klint version and the SHA-256 of the skill it came from. Every later run compares that hash against the skill the installed klint ships:
+
+```
+.agents/skills/klint-rules/SKILL.md:1  warn  klint/skill-stale
+  this klint-rules skill was installed from klint 0.32.0 and no longer matches klint 0.33.0 — reinstall it with: klint install-skill
+```
+
+In the shared layout this fires once, not once per symlink. Hand-copied or edited skills have no receipt, so they are never flagged — and `install-skill` refuses to overwrite them unless you pass `--force`.
+
+Earlier versions symlinked into `node_modules/@konvert7/klint`, which breaks the moment dependencies are reinstalled. klint now reports those:
+
+```
+.claude/skills/klint-rules:1  warn  klint/skill-legacy-link
+  this skill is a symlink into node_modules (../../node_modules/@konvert7/klint/skill/klint-rules), which breaks as soon as dependencies are reinstalled — run: klint install-skill
+```
+
+Running `klint install-skill` replaces those links with the shared layout, including links whose target is already gone. No `--force` needed — a symlink holds no content to lose.
+
 ## Engines
 
 klint currently ships a TypeScript engine and an experimental Rust engine. The Rust path is built for portable architecture checks and syntax-local rules; type-aware checks stay in TypeScript for now.

package/cli/help.ts

@@ -13,7 +13,7 @@ export function printHelp(): void {
       "klint — agent harness for TypeScript architecture rules",
       "",
       "Usage: klint [--config <dir>] [--rules <file>] [--engine ts|rust|compare|auto] [--fix] [--json]",
-      "       klint install-skill [--agents <list>] [--symlink | --copy]",
+      "       klint install-skill [--agents <list>] [--symlink | --copy] [--force]",
       "",
       "  --config <dir>   directory containing klint.yaml or klint.config.json (default: cwd)",
       "  --rules  <file>  custom rules file (default: <configDir>/klint.rules.ts if present)",
@@ -24,8 +24,14 @@ export function printHelp(): void {
       "",
       "  install-skill    install the rule-authoring skill into agent config directories",
       "                   --agents <list>  comma-separated: claude,opencode,cursor,codex (default: all)",
-      "                   --symlink        install as symlink (stays in sync with updates)",
-      "                   --copy           install as copy (default in non-TTY)",
+      "                   --symlink        keep one skill in .agents/skills and symlink the",
+      "                                    other agents to it (default)",
+      "                   --copy           give every agent directory its own copy",
+      "                   --force          replace a skill directory klint did not install",
+      "",
+      "  Installed skills record the version and hash they came from. klint warns with",
+      "  klint/skill-stale once the shipped skill moves on, and with",
+      "  klint/skill-legacy-link for old symlinks that point into node_modules.",
       "",
       `Built-in rules (${standaloneRules.length}):`,
       ...standaloneRules.map((r) => `  ${r}`),

package/cli/install-skill.ts

@@ -1,102 +1,264 @@
 import { existsSync } from "node:fs";
-import { cp, mkdir, rm, symlink } from "node:fs/promises";
+import { cp, lstat, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import * as clack from "@clack/prompts";
-import { PACKAGE_ROOT } from "./paths";
+import {
+  AGENT_SKILL_DIRS,
+  type AgentKey,
+  agentSkillDirs,
+  CANONICAL_SKILL_DIR,
+  RECEIPT_FILE_NAME,
+  SKILL_DIR_NAME,
+  SKILL_FILE_NAME,
+  type SkillReceipt,
+  skillHash,
+} from "../core/skill";
+import { installedVersion, PACKAGE_ROOT } from "./paths";
 
 const AGENT_TARGETS = [
   { value: "claude", label: "Claude Code" },
   { value: "opencode", label: "opencode" },
   { value: "cursor", label: "Cursor" },
   { value: "codex", label: "Codex" },
-] as const;
+] as const satisfies ReadonlyArray<{ value: AgentKey; label: string }>;
 
-type AgentKey = (typeof AGENT_TARGETS)[number]["value"];
-
-const AGENT_DIRS: Record<AgentKey, string> = {
-  claude: ".claude/skills",
-  opencode: ".agents/skills",
-  cursor: ".cursor/skills",
-  codex: ".agents/skills",
-};
+interface InstallPlan {
+  agents: AgentKey[];
+  shared: boolean;
+  force: boolean;
+}
 
 export async function installSkill(args: string[]): Promise<void> {
-  const skillSrc = join(PACKAGE_ROOT, "skill", "klint-rules");
+  const skillSrc = join(PACKAGE_ROOT, "skill", SKILL_DIR_NAME);
   if (!existsSync(skillSrc)) {
     process.stderr.write(`klint: skill source not found at ${skillSrc}\n`);
     process.exit(1);
   }
 
-  // Parse non-interactive flags
-  let flagAgents: AgentKey[] | undefined;
-  let flagSymlink: boolean | undefined;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--agents" && args[i + 1])
-      flagAgents = args[++i].split(",") as AgentKey[];
-    else if (args[i] === "--symlink") flagSymlink = true;
-    else if (args[i] === "--copy") flagSymlink = false;
+  const plan = await resolvePlan(args);
+  const dirs = agentSkillDirs(plan.agents);
+
+  try {
+    const report = plan.shared
+      ? await installShared({ dirs, force: plan.force, skillSrc })
+      : await installCopies({ dirs, force: plan.force, skillSrc });
+    for (const line of report) process.stdout.write(`klint: ${line}\n`);
+  } catch (error) {
+    process.stderr.write(`${(error as Error).message}\n`);
+    process.exit(1);
   }
 
-  let selectedAgents: AgentKey[];
-  let useSymlink: boolean;
+  if (process.stdin.isTTY) {
+    clack.outro("Done.");
+  }
+}
 
-  if (!process.stdin.isTTY || flagAgents !== undefined || flagSymlink !== undefined) {
-    selectedAgents = flagAgents ?? (AGENT_TARGETS.map((a) => a.value) as AgentKey[]);
-    useSymlink = flagSymlink ?? false;
-  } else {
-    clack.intro("klint install-skill");
+async function installShared({
+  dirs,
+  force,
+  skillSrc,
+}: {
+  dirs: string[];
+  force: boolean;
+  skillSrc: string;
+}): Promise<string[]> {
+  const hub = join(CANONICAL_SKILL_DIR, SKILL_DIR_NAME);
+  const report = [await installCopy(hub, skillSrc, force)];
 
-    const agents = await clack.multiselect<AgentKey>({
-      message: "Which agents should the skill be installed for?",
-      options: AGENT_TARGETS.map((a) => ({ value: a.value, label: a.label })),
-      initialValues: AGENT_TARGETS.map((a) => a.value) as AgentKey[],
-    });
-    if (clack.isCancel(agents)) {
-      clack.cancel("Cancelled.");
-      process.exit(0);
-    }
-    selectedAgents = agents as AgentKey[];
-
-    const mode = await clack.select<"symlink" | "copy">({
-      message: "Install as symlink or copy?",
-      options: [
-        {
-          value: "symlink",
-          label: "Symlink",
-          hint: "stays in sync when klint updates",
-        },
-        {
-          value: "copy",
-          label: "Copy",
-          hint: "one-time snapshot, no ongoing dependency",
-        },
-      ],
-    });
-    if (clack.isCancel(mode)) {
-      clack.cancel("Cancelled.");
-      process.exit(0);
-    }
-    useSymlink = mode === "symlink";
+  for (const dir of dirs) {
+    if (dir === CANONICAL_SKILL_DIR) continue;
+    report.push(await linkToHub(join(dir, SKILL_DIR_NAME), hub, skillSrc, force));
   }
+  return report;
+}
 
-  const cwd = process.cwd();
-  const linkType = process.platform === "win32" ? "junction" : "dir";
-  for (const key of selectedAgents) {
-    const dest = resolve(cwd, AGENT_DIRS[key], "klint-rules");
-    await mkdir(dirname(dest), { recursive: true });
-    try {
-      await rm(dest, { recursive: true, force: true });
-    } catch {
-      /* already gone */
-    }
-    if (useSymlink) {
-      await symlink(relative(dirname(dest), skillSrc), dest, linkType);
-    } else {
-      await cp(skillSrc, dest, { recursive: true });
+async function installCopies({
+  dirs,
+  force,
+  skillSrc,
+}: {
+  dirs: string[];
+  force: boolean;
+  skillSrc: string;
+}): Promise<string[]> {
+  const report: string[] = [];
+  for (const dir of dirs) {
+    report.push(await installCopy(join(dir, SKILL_DIR_NAME), skillSrc, force));
+  }
+  return report;
+}
+
+async function installCopy(
+  target: string,
+  skillSrc: string,
+  force: boolean
+): Promise<string> {
+  const dest = resolve(process.cwd(), target);
+  await prepareDestination(dest, target, force);
+  await cp(skillSrc, dest, { recursive: true });
+  await writeReceipt(dest, skillSrc);
+  return `installed ${target}`;
+}
+
+async function linkToHub(
+  target: string,
+  hub: string,
+  skillSrc: string,
+  force: boolean
+): Promise<string> {
+  const dest = resolve(process.cwd(), target);
+  await prepareDestination(dest, target, force);
+
+  const absoluteHub = resolve(process.cwd(), hub);
+  const linkPath = relative(dirname(dest), absoluteHub);
+  if (await linkResolves(linkPath, dest, "dir")) return `linked ${target} -> ${linkPath}`;
+  if (await linkResolves(absoluteHub, dest, "junction"))
+    return `linked ${target} -> ${hub}`;
+
+  await cp(skillSrc, dest, { recursive: true });
+  await writeReceipt(dest, skillSrc);
+  return `installed ${target} (symlinks unavailable here)`;
+}
+
+async function linkResolves(
+  linkTarget: string,
+  dest: string,
+  type: "dir" | "junction"
+): Promise<boolean> {
+  try {
+    await symlink(linkTarget, dest, type);
+    if (existsSync(join(dest, SKILL_FILE_NAME))) return true;
+  } catch {
+    /* try the next strategy */
+  }
+  await rm(dest, { force: true, recursive: true });
+  return false;
+}
+
+async function prepareDestination(
+  dest: string,
+  target: string,
+  force: boolean
+): Promise<void> {
+  await mkdir(dirname(dest), { recursive: true });
+
+  const existing = await lstat(dest).catch(() => undefined);
+  if (existing === undefined) return;
+
+  if (!existing.isDirectory() || existsSync(join(dest, RECEIPT_FILE_NAME)) || force) {
+    await rm(dest, { force: true, recursive: true });
+    return;
+  }
+
+  throw new Error(
+    `klint: ${target} exists and was not installed by klint — pass --force to replace it`
+  );
+}
+
+async function writeReceipt(dest: string, skillSrc: string): Promise<void> {
+  const receipt: SkillReceipt = {
+    version: installedVersion(),
+    sha256: skillHash(await readFile(join(skillSrc, SKILL_FILE_NAME))),
+  };
+  await writeFile(join(dest, RECEIPT_FILE_NAME), `${JSON.stringify(receipt, null, 2)}\n`);
+}
+
+async function resolvePlan(args: string[]): Promise<InstallPlan> {
+  const flags = parseFlags(args);
+  const decided = flags.agents !== undefined || flags.shared !== undefined;
+
+  if (!process.stdin.isTTY || decided) {
+    return {
+      agents: flags.agents ?? everyAgent(),
+      shared: flags.shared ?? true,
+      force: flags.force,
+    };
+  }
+
+  clack.intro("klint install-skill");
+  return {
+    agents: await promptForAgents(),
+    shared: await promptForShared(),
+    force: flags.force,
+  };
+}
+
+function parseFlags(args: string[]): {
+  agents?: AgentKey[];
+  shared?: boolean;
+  force: boolean;
+} {
+  let agents: AgentKey[] | undefined;
+  let shared: boolean | undefined;
+  let force = false;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--agents" && args[i + 1]) agents = parseAgents(args[++i]);
+    else if (args[i] === "--symlink" || args[i] === "--shared") shared = true;
+    else if (args[i] === "--copy") shared = false;
+    else if (args[i] === "--force") force = true;
+    else {
+      process.stderr.write(`klint: unknown install-skill argument "${args[i]}"\n`);
+      process.exit(1);
     }
   }
 
-  if (process.stdin.isTTY) {
-    clack.outro("Done.");
+  return { agents, force, shared };
+}
+
+function parseAgents(value: string): AgentKey[] {
+  return value
+    .split(",")
+    .map((agent) => agent.trim())
+    .filter((agent) => agent.length > 0)
+    .map((agent) => {
+      if (!(agent in AGENT_SKILL_DIRS)) {
+        process.stderr.write(
+          `klint: unknown agent "${agent}" (expected one of: ${everyAgent().join(", ")})\n`
+        );
+        process.exit(1);
+      }
+      return agent as AgentKey;
+    });
+}
+
+function everyAgent(): AgentKey[] {
+  return AGENT_TARGETS.map((target) => target.value);
+}
+
+async function promptForAgents(): Promise<AgentKey[]> {
+  const agents = await clack.multiselect<AgentKey>({
+    message: "Which agents should the skill be installed for?",
+    options: AGENT_TARGETS.map((a) => ({ value: a.value, label: a.label })),
+    initialValues: everyAgent(),
+  });
+  if (clack.isCancel(agents)) {
+    clack.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return agents as AgentKey[];
+}
+
+async function promptForShared(): Promise<boolean> {
+  const mode = await clack.select<"shared" | "copy">({
+    message: "How should the skill be stored?",
+    initialValue: "shared",
+    options: [
+      {
+        value: "shared",
+        label: "Shared (recommended)",
+        hint: `one skill in ${CANONICAL_SKILL_DIR}, other agents symlink to it`,
+      },
+      {
+        value: "copy",
+        label: "Separate copies",
+        hint: "an independent copy in every agent directory",
+      },
+    ],
+  });
+  if (clack.isCancel(mode)) {
+    clack.cancel("Cancelled.");
+    process.exit(0);
   }
+  return mode === "shared";
 }

package/cli/paths.ts

@@ -1,3 +1,20 @@
+import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 export const PACKAGE_ROOT = resolve(import.meta.dir, "..");
+
+export const SHIPPED_SKILL_PATH = resolve(
+  PACKAGE_ROOT,
+  "skill",
+  "klint-rules",
+  "SKILL.md"
+);
+
+export function installedVersion(): string {
+  try {
+    const manifest = readFileSync(resolve(PACKAGE_ROOT, "package.json"), "utf-8");
+    return (JSON.parse(manifest) as { version?: string }).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}

package/cli.ts

@@ -12,22 +12,14 @@ import {
   writeDebugEvent,
   writeTextOutput,
 } from "./cli/output";
-import { PACKAGE_ROOT } from "./cli/paths";
+import { installedVersion, SHIPPED_SKILL_PATH } from "./cli/paths";
 import { runAutoEngine, runCompareEngine, runRustEngine } from "./cli/rust-engine";
 import { applyFixes } from "./core/fixer";
 import { runKlint } from "./core/runner";
 import { schemaVersionAdvisory } from "./core/schema-version";
+import { skillAdvisories } from "./core/skill";
 import type { ArchConfig, KlintConfig, KlintRule, RuleConfigValue } from "./core/types";
 
-async function installedVersion(): Promise<string> {
-  const manifest = await readFile(resolve(PACKAGE_ROOT, "package.json"), "utf-8");
-  try {
-    return (JSON.parse(manifest) as { version?: string }).version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
 interface CliOptions {
   configDir?: string;
   rulesFile?: string;
@@ -42,8 +34,9 @@ export async function main(opts: CliOptions = {}): Promise<void> {
     process.exit(0);
   }
 
-  if (args[0] === "install-skill") {
-    await installSkill(args.slice(1));
+  const subcommand = args.indexOf("install-skill");
+  if (subcommand !== -1) {
+    await installSkill(args.slice(subcommand + 1));
     return;
   }
 
@@ -65,8 +58,11 @@ export async function main(opts: CliOptions = {}): Promise<void> {
       printHelp();
       process.exit(0);
     } else if (args[i] === "--version" || args[i] === "-V") {
-      process.stdout.write(`klint ${await installedVersion()}\n`);
+      process.stdout.write(`klint ${installedVersion()}\n`);
       process.exit(0);
+    } else {
+      process.stderr.write(`klint: unknown argument "${args[i]}"\n`);
+      process.exit(1);
     }
   }
 
@@ -103,12 +99,20 @@ export async function main(opts: CliOptions = {}): Promise<void> {
   }
   const root = resolve(configDir, raw.root ?? ".");
 
-  const advisories = schemaVersionAdvisory({
-    schema: raw.$schema,
-    installed: await installedVersion(),
-    configFile: usingYaml ? "klint.yaml" : "klint.config.json",
-    configText,
-  });
+  const installed = installedVersion();
+  const advisories = [
+    ...schemaVersionAdvisory({
+      schema: raw.$schema,
+      installed,
+      configFile: usingYaml ? "klint.yaml" : "klint.config.json",
+      configText,
+    }),
+    ...skillAdvisories({
+      configDir,
+      installed,
+      shippedSkillPath: SHIPPED_SKILL_PATH,
+    }),
+  ];
 
   if (engine === "rust") {
     runRustEngine({ advisories, fix, json, raw, root, rulesFile, startedAt });

package/core/skill.ts

@@ -0,0 +1,163 @@
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync, readlinkSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import type { Violation } from "./types";
+
+export const AGENT_SKILL_DIRS = {
+  claude: ".claude/skills",
+  codex: ".agents/skills",
+  cursor: ".cursor/skills",
+  opencode: ".agents/skills",
+} as const;
+
+export type AgentKey = keyof typeof AGENT_SKILL_DIRS;
+
+export const CANONICAL_SKILL_DIR = ".agents/skills";
+export const SKILL_DIR_NAME = "klint-rules";
+export const SKILL_FILE_NAME = "SKILL.md";
+export const RECEIPT_FILE_NAME = ".klint-skill.json";
+
+const STALE_RULE = "klint/skill-stale";
+const LEGACY_RULE = "klint/skill-legacy-link";
+const LEGACY_TARGET = "node_modules";
+
+export interface SkillReceipt {
+  version: string;
+  sha256: string;
+}
+
+export function skillHash(contents: Buffer | string): string {
+  return createHash("sha256").update(contents).digest("hex");
+}
+
+export function agentSkillDirs(agents?: readonly AgentKey[]): string[] {
+  const selected = (agents ?? (Object.keys(AGENT_SKILL_DIRS) as AgentKey[])).map(
+    (agent) => AGENT_SKILL_DIRS[agent]
+  );
+  return [...new Set(selected)];
+}
+
+export function skillAdvisories({
+  configDir,
+  installed,
+  shippedSkillPath,
+}: {
+  configDir: string;
+  installed: string;
+  shippedSkillPath: string;
+}): Array<Omit<Violation, "fix">> {
+  return [
+    ...legacyLinkAdvisories(configDir),
+    ...stalenessAdvisories({ configDir, installed, shippedSkillPath }),
+  ];
+}
+
+function legacyLinkAdvisories(configDir: string): Array<Omit<Violation, "fix">> {
+  return agentSkillDirs().flatMap((dir) => {
+    const target = symlinkTarget(join(configDir, dir, SKILL_DIR_NAME));
+    if (target === undefined || !target.includes(LEGACY_TARGET)) return [];
+    return [
+      {
+        file: `${dir}/${SKILL_DIR_NAME}`,
+        line: 1,
+        rule: LEGACY_RULE,
+        severity: "warn",
+        message: `this skill is a symlink into ${LEGACY_TARGET} (${target}), which breaks as soon as dependencies are reinstalled — run: klint install-skill`,
+      },
+    ];
+  });
+}
+
+function stalenessAdvisories({
+  configDir,
+  installed,
+  shippedSkillPath,
+}: {
+  configDir: string;
+  installed: string;
+  shippedSkillPath: string;
+}): Array<Omit<Violation, "fix">> {
+  const shipped = readShippedHash(shippedSkillPath);
+  if (shipped === undefined) return [];
+
+  const reported = new Set<string>();
+  return realSkillDirsFirst(configDir).flatMap((dir) => {
+    const skillDir = join(configDir, dir, SKILL_DIR_NAME);
+    const canonical = resolveSkillDir(skillDir);
+    if (canonical === undefined || reported.has(canonical)) return [];
+
+    const receipt = readReceipt(join(skillDir, RECEIPT_FILE_NAME));
+    if (receipt === undefined || receipt.sha256 === shipped) return [];
+
+    reported.add(canonical);
+    return [staleAdvisory(dir, receipt.version, installed)];
+  });
+}
+
+function staleAdvisory(
+  dir: string,
+  installedFrom: string,
+  installed: string
+): Omit<Violation, "fix"> {
+  return {
+    file: `${dir}/${SKILL_DIR_NAME}/${SKILL_FILE_NAME}`,
+    line: 1,
+    rule: STALE_RULE,
+    severity: "warn",
+    message: `this klint-rules skill was installed from klint ${installedFrom} and no longer matches klint ${installed} — reinstall it with: klint install-skill`,
+  };
+}
+
+function realSkillDirsFirst(configDir: string): string[] {
+  const dirs = agentSkillDirs();
+  const linked = new Set(
+    dirs.filter(
+      (dir) => symlinkTarget(join(configDir, dir, SKILL_DIR_NAME)) !== undefined
+    )
+  );
+  return [...dirs.filter((dir) => !linked.has(dir)), ...linked];
+}
+
+function symlinkTarget(path: string): string | undefined {
+  try {
+    if (!lstatSync(path).isSymbolicLink()) return undefined;
+    return readlinkSync(path);
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveSkillDir(path: string): string | undefined {
+  try {
+    return realpathSync(path);
+  } catch {
+    return undefined;
+  }
+}
+
+function readShippedHash(shippedSkillPath: string): string | undefined {
+  try {
+    return skillHash(readFileSync(shippedSkillPath));
+  } catch {
+    return undefined;
+  }
+}
+
+function readReceipt(path: string): SkillReceipt | undefined {
+  let text: string;
+  try {
+    text = readFileSync(path, "utf-8");
+  } catch {
+    return undefined;
+  }
+
+  try {
+    const parsed = JSON.parse(text) as Partial<SkillReceipt>;
+    if (typeof parsed.version !== "string" || typeof parsed.sha256 !== "string") {
+      return undefined;
+    }
+    return { version: parsed.version, sha256: parsed.sha256 };
+  } catch {
+    return undefined;
+  }
+}

package/klint.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.33.0/klint.schema.json",
+  "$id": "https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.33.1/klint.schema.json",
   "type": "object",
   "properties": {
     "$schema": {

package/klint.schema.yaml

@@ -1,5 +1,5 @@
 $schema: http://json-schema.org/draft-07/schema#
-$id: https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.33.0/klint.schema.json
+$id: https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.33.1/klint.schema.json
 type: object
 properties:
   $schema:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konvert7/klint",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "description": "Architecture-as-Code linter for TypeScript. Enforce layer boundaries, import rules, and singleton patterns in YAML.",
   "type": "module",
   "bin": {
@@ -70,10 +70,10 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@konvert7/klint-darwin-arm64": "0.33.0",
-    "@konvert7/klint-darwin-x64": "0.33.0",
-    "@konvert7/klint-linux-x64": "0.33.0",
-    "@konvert7/klint-win32-x64": "0.33.0"
+    "@konvert7/klint-darwin-arm64": "0.33.1",
+    "@konvert7/klint-darwin-x64": "0.33.1",
+    "@konvert7/klint-linux-x64": "0.33.1",
+    "@konvert7/klint-win32-x64": "0.33.1"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.7",