@konvert7/klint 0.21.0 → 0.23.0

package/README.md

@@ -1,8 +1,8 @@
 # klint
 
-Architecture and type-aware linting for TypeScript projects.
+Architecture-as-Code linting for TypeScript, Python, and Swift projects.
 
-Biome and oxlint are excellent at syntax, style, and fast local correctness. klint handles the rules that need project context: layer boundaries, singleton ownership, forbidden patterns, custom repository policies, and type-aware checks that should block an AI agent or CI run before code lands.
+Biome, oxlint, Ruff, and SwiftLint are excellent at syntax, style, and fast local correctness. klint handles the rules that need project context: layer boundaries, singleton ownership, forbidden patterns, custom repository policies, and type-aware TypeScript checks that should block an AI agent or CI run before code lands.
 
 Use klint when "please follow AGENTS.md" is not strong enough. Put the rule in `klint.yaml`, run `klint`, and make the constraint executable.
 
@@ -190,7 +190,7 @@ arch:
       message: "Client code must not import server-only modules"
 ```
 
-`include` selects `.ts` files to lint. Patterns support `**` globs and `!` negation.
+`include` selects source files to lint. Patterns support `**` globs and `!` negation.
 
 `plugins` enables bundled rule groups. Today, `sonar` provides focused code-quality rules.
 
@@ -279,6 +279,83 @@ arch:
       message: "Use the auth module"
 ```
 
+### Python Architecture Checks
+
+The Rust engine can apply architecture rules to Python projects:
+
+```yaml
+include: ["src"]
+
+rules: {}
+
+arch:
+  layers:
+    jobs: ["src/app/jobs/**"]
+    lib: ["src/app/lib/**"]
+    config: ["src/app/config.py"]
+
+  imports:
+    - from: jobs
+      deny: lib
+      message: "Jobs must use service APIs, not import lib directly"
+
+  forbidden:
+    - pattern: "print("
+      in: jobs
+      message: "Use the logger"
+
+  singleton:
+    - pattern: "os.environ[\"API_KEY\"]"
+      only: "src/app/config.py"
+      in: ["src/**"]
+      message: "Use app config"
+```
+
+Python import checks support relative imports such as
+`from ..lib.auth import load_key` and project-resolvable absolute imports such
+as `from app.lib.auth import load_key`. External packages that do not resolve to
+project files, such as `requests`, are ignored. This is architecture
+enforcement, not full packaging or virtual-environment analysis.
+
+### Swift Architecture Checks
+
+The Rust engine can apply architecture rules to Swift projects:
+
+```yaml
+include: ["Sources"]
+
+rules: {}
+
+arch:
+  layers:
+    ui: ["Sources/App/UI/**"]
+    core: ["Sources/App/Core/**"]
+    config: ["Sources/App/Config/**"]
+
+  imports:
+    - from: ui
+      deny: core
+      message: "UI must use app services, not import Core directly"
+
+  forbidden:
+    - pattern: "URLSession.shared"
+      in: ui
+      message: "Use the networking client"
+
+  singleton:
+    - pattern: "ProcessInfo.processInfo.environment[\"API_KEY\"]"
+      only: "Sources/App/Config/AppConfig.swift"
+      in: ["Sources/**"]
+      message: "Use AppConfig"
+```
+
+Swift import checks parse declarations such as `import Core`,
+`@_exported import Core`, and `import struct Models.User`. Imported modules
+resolve against discovered project Swift directories and file stems. System or
+package modules that are not present in the project, such as `Foundation`, are
+ignored. This is architecture enforcement, not full SwiftPM or Xcode build graph
+analysis.
+
 ## Built-in Rules
 
 | Rule | Type-aware | Description |

package/package.json

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

package/tools/prepare-python-release.ts

@@ -0,0 +1,76 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+interface Options {
+  name: string;
+  root: string;
+  version: string;
+}
+
+const repoRoot = fileURLToPath(new URL("..", import.meta.url));
+const options = parseArgs();
+const pythonRoot = join(options.root, "python");
+const pyprojectPath = join(pythonRoot, "pyproject.toml");
+const initPath = join(pythonRoot, "klint", "__init__.py");
+
+const pyproject = readFileSync(pyprojectPath, "utf-8");
+const nextPyproject = replaceRequired(
+  replaceRequired(pyproject, /^name = ".+"$/m, `name = "${options.name}"`, pyprojectPath),
+  /^version = ".+"$/m,
+  `version = "${options.version}"`,
+  pyprojectPath
+);
+writeFileSync(pyprojectPath, nextPyproject);
+
+const init = readFileSync(initPath, "utf-8");
+const nextInit = replaceRequired(
+  init,
+  /^__version__ = ".+"$/m,
+  `__version__ = "${options.version}"`,
+  initPath
+);
+writeFileSync(initPath, nextInit);
+
+process.stdout.write(
+  `prepared Python release metadata: ${options.name}@${options.version}\n`
+);
+
+function parseArgs(): Options {
+  const args = process.argv.slice(2);
+  const name = valueAfter(args, "--name");
+  const version = valueAfter(args, "--version");
+  if (!name || !version) {
+    fail(
+      "Usage: bun tools/prepare-python-release.ts --name <package-name> --version <version> [--root <repo-root>]"
+    );
+  }
+
+  return {
+    name,
+    version,
+    root: resolve(valueAfter(args, "--root") ?? repoRoot),
+  };
+}
+
+function replaceRequired(
+  input: string,
+  pattern: RegExp,
+  replacement: string,
+  path: string
+): string {
+  if (!pattern.test(input)) {
+    fail(`Expected release metadata pattern ${pattern} in ${path}`);
+  }
+  return input.replace(pattern, replacement);
+}
+
+function valueAfter(args: string[], name: string): string | undefined {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function fail(message: string): never {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}