@freetesh/canon 0.16.0 → 0.17.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     {
       "name": "canon",
       "source": "./",
-      "version": "0.16.0",
+      "version": "0.17.0",
       "description": "Keeps your domain knowledge and AI rules in your repos and enforces them, so Claude hallucinates less."
     }
   ],

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "canon",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Keeps your domain knowledge and AI rules in your repos and enforces them, so Claude hallucinates less."
 }

package/README.md

@@ -47,9 +47,11 @@ is a separate paid product built on this CLI.
   listing tree, dead `.context/` paths, prices with no canonical home, shared
   files, the import architecture, pipeline gates, and every checker your config
   declares. `canon hooks install` makes every push run it.
-- **Standards with one home.** canon ships defaults; an estate adds or replaces
-  them from its own folder; a repo can override again. `canon standards` shows
-  what applies.
+- **Standards with one home.** canon ships defaults every repo follows, and a
+  library a repo imports by name (`standards: [design-sets, pipeline]`): design
+  sets, the build pipeline, Expo, frontend, performance, secrets, store listings.
+  A repo's own rules can sit in a folder it adds. `canon standards` shows what
+  applies.
 - **A repo names only what it uses.** Modules, packs and shared-file sets are
   opt-in; there is no skip list and no setting that turns a check off.
 
@@ -97,9 +99,8 @@ repo whose `canon.yaml` says `estate: true`, or `CANON_ESTATE`.
 ```yaml
 # <estate>/.claude/canon.yaml — shared by every repo below it
 estate: true
-standards: [.canon/standards]       # estate rules; same name replaces a canon default
 commands:                           # your own checkers, run by `canon check`
-  - { id: designs, run: ./scripts/check-designs.sh, if: .context/designs, module: design }
+  - { id: lint-copy, run: ./scripts/lint-copy.sh, if: .context/designs, module: design }
   - { id: designs-first, run: test -d .context/designs, kinds: [mobile, web] }   # only repos that ship screens
 copies:                             # files products copy from one source repo, in named sets
   source: design-system
@@ -111,8 +112,9 @@ copies:                             # files products copy from one source repo,
 
 ```yaml
 # <repo>/.claude/canon.yaml — written by `canon init`
-canon: 0.16.0
+canon: 0.17.0
 kind: mobile                        # mobile | web | mobile-and-web | package | content
+standards: [design-sets, pipeline, expo]   # canon's library standards this repo follows; ./rules adds a folder of its own
 modules: [docs, knowledge, code, listing, refs]
 packs: [expo]
 name: Acme                          # how the product is written; `named` copies swap it in

package/cli/dist/checks/designs.d.ts

@@ -0,0 +1,5 @@
+import type { Check } from "./types.ts";
+/** Every drawn surface: a folder under .context/designs/ with a routes.js manifest. */
+export declare function designSurfaces(repo: string): string[];
+/** Runs canon's design-set checker (scripts/check-designs.py) once per drawn surface. */
+export declare const designs: Check;

package/cli/dist/checks/designs.js

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+const DESIGNS = ".context/designs";
+const MAX_OUTPUT_LINES = 15;
+/** Every drawn surface: a folder under .context/designs/ with a routes.js manifest. */
+export function designSurfaces(repo) {
+    const root = join(repo, DESIGNS);
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, "routes.js")))
+        .map((entry) => `${DESIGNS}/${entry.name}`)
+        .sort();
+}
+/** Runs canon's design-set checker (scripts/check-designs.py) once per drawn surface. */
+export const designs = {
+    id: "designs",
+    module: "design",
+    description: "every drawn surface follows the design-sets standard (scripts/check-designs.py)",
+    run({ repo, canonRoot }) {
+        const script = join(canonRoot, "scripts", "check-designs.py");
+        return designSurfaces(repo).flatMap((surface) => {
+            const result = spawnSync("python3", [script, surface], { cwd: repo, encoding: "utf8" });
+            if (result.error)
+                return [{ check: "designs", level: "error", file: surface, message: `could not run python3: ${result.error.message}` }];
+            if (result.status === 0)
+                return [];
+            const output = `${result.stdout}\n${result.stderr}`.trim().split("\n").slice(-MAX_OUTPUT_LINES).join("\n");
+            return [{ check: "designs", level: "error", file: surface, message: output }];
+        });
+    },
+};

package/cli/dist/checks/index.js

@@ -5,6 +5,7 @@ import { contextSize } from "./context-size.js";
 import { staleCopies } from "./stale-copies.js";
 import { standardsCopies } from "./standards-copies.js";
 import { commandChecks } from "./commands.js";
+import { designs } from "./designs.js";
 import { features } from "./features.js";
 import { listing } from "./listing.js";
 import { metricsDefinitions } from "./metrics-definitions.js";
@@ -30,5 +31,6 @@ export const ALL_CHECKS = [
     metricsDefinitions,
     sources,
     pipeline,
+    designs,
     commandChecks,
 ];

package/cli/dist/config/load.js

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { parse } from "yaml";
-import { MODULES_BY_KIND, layerSchema } from "./schema.js";
+import { isStandardName, MODULES_BY_KIND, layerSchema } from "./schema.js";
 const EXPO_MARKERS = ["app.config.ts", "app.config.js", "app.json"];
 const WEB_MARKERS = ["next.config.ts", "next.config.js", "next.config.mjs", "vite.config.ts"];
 function configPath(folder) {
@@ -94,7 +94,7 @@ export function loadConfig(repo, options = {}) {
         modules: lastDefined(pick("modules")) ?? inferModules(repo, kind),
         expo: Object.assign({}, ...pick("expo")),
         packs: [...new Set(pick("packs").flatMap((packs) => packs ?? []))].sort(),
-        standards: [...new Set(layers.flatMap((layer) => (layer.data.standards ?? []).map((dir) => resolve(layer.base, dir))))],
+        standards: [...new Set(layers.flatMap((layer) => (layer.data.standards ?? []).map((entry) => (isStandardName(entry) ? entry : resolve(layer.base, entry)))))],
         commands: mergeBy(pick("commands").map((list) => list ?? []), (command) => command.id),
         doctor: { tools: mergeBy(pick("doctor").map((doctor) => doctor?.tools ?? []), (tool) => tool.tool) },
         weigh: { weights: Object.assign({}, ...pick("weigh").map((weigh) => weigh?.weights)) },

package/cli/dist/config/schema.d.ts

@@ -11,6 +11,8 @@ export declare const WIKI_FOLDER_BY_TYPE: Record<string, string>;
 export declare const REMOVED_WIKI_FOLDERS: Record<string, string>;
 /** The `.context/` folders every repo may have. A repo adds more under `context.folders`. */
 export declare const CONTEXT_FOLDERS: string[];
+/** A `standards:` entry naming a library standard rather than a folder path. */
+export declare function isStandardName(entry: string): boolean;
 export type Kind = (typeof KINDS)[number];
 export type Module = (typeof MODULES)[number];
 declare const command: z.ZodObject<{
@@ -167,7 +169,7 @@ export interface Config {
         sdk?: number;
     };
     packs: string[];
-    /** Absolute standards folders, estate first; a later file of the same name wins. */
+    /** Library standard names and absolute folders, estate first; a later file of the same name wins. */
     standards: string[];
     commands: CommandSpec[];
     doctor: {

package/cli/dist/config/schema.js

@@ -19,6 +19,10 @@ export const REMOVED_WIKI_FOLDERS = {
 };
 /** The `.context/` folders every repo may have. A repo adds more under `context.folders`. */
 export const CONTEXT_FOLDERS = ["raw", "wiki", "features", "designs", "listing", "marketing", "metrics", "support", "legal", "ops"];
+/** A `standards:` entry naming a library standard rather than a folder path. */
+export function isStandardName(entry) {
+    return /^[a-z0-9-]+$/.test(entry);
+}
 const principleId = z.string().regex(/^C-\d{2}$/, "principle IDs look like C-07");
 const command = z
     .object({
@@ -83,7 +87,7 @@ export const layerSchema = z
     modules: z.array(z.enum(MODULES)),
     expo: z.object({ sdk: z.number().int().positive() }).partial(),
     packs: z.array(z.string().regex(/^[a-z0-9-]+$/, "pack names are lowercase-kebab")),
-    /** Folders of extra standards, relative to the folder that holds `.claude/`. */
+    /** Standards to add: a bare name imports canon's library standard (`design-sets`); a path (`./rules`) is a folder of the repo's own. */
     standards: z.array(z.string()),
     commands: z.array(command),
     doctor: z.object({ tools: z.array(tool) }).partial(),

package/cli/dist/standards.d.ts

@@ -4,11 +4,16 @@ export interface Standard {
     /** "canon" for a built-in default, else the configured folder it came from. */
     from: string;
 }
-/** canon's default standards, then each configured folder in order; a later file of the same name replaces an earlier one. */
-export declare function resolveStandards(canonRoot: string, folders: string[]): Standard[];
+/** The opt-in standards canon ships; a repo imports one by name under `standards:`. */
+export declare function libraryStandards(canonRoot: string): string[];
 /**
- * Principle headings from canon's constitution and every configured one. A
- * constitution in a folder extends rather than replaces: it adds principles,
- * and restating an ID rewords it.
+ * canon's defaults, then each `standards:` entry in order: a name imports canon's library
+ * standard, a folder adds its files. A later file of the same name replaces an earlier one.
  */
-export declare function constitutionTitles(canonRoot: string, folders: string[]): string[];
+export declare function resolveStandards(canonRoot: string, entries: string[]): Standard[];
+/**
+ * Principle headings from canon's constitution, every imported library standard
+ * and every configured folder's constitution. They extend rather than replace:
+ * each adds principles, and restating an ID rewords it.
+ */
+export declare function constitutionTitles(canonRoot: string, entries: string[]): string[];

package/cli/dist/standards.js

@@ -1,35 +1,55 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { isStandardName } from "./config/schema.js";
 const NOT_STANDARDS = new Set(["README.md"]);
 const PRINCIPLE = /^### (C-\d{2}) (.+)$/;
 function markdownIn(dir) {
     return readdirSync(dir).filter((file) => file.endsWith(".md") && !NOT_STANDARDS.has(file));
 }
-/** canon's default standards, then each configured folder in order; a later file of the same name replaces an earlier one. */
-export function resolveStandards(canonRoot, folders) {
+/** The opt-in standards canon ships; a repo imports one by name under `standards:`. */
+export function libraryStandards(canonRoot) {
+    const dir = join(canonRoot, "standards", "library");
+    return existsSync(dir) ? markdownIn(dir).map((file) => file.replace(/\.md$/, "")).sort() : [];
+}
+function libraryFile(canonRoot, name) {
+    const path = join(canonRoot, "standards", "library", `${name}.md`);
+    if (!existsSync(path))
+        throw new Error(`no canon standard named ${name} — canon has: ${libraryStandards(canonRoot).join(", ")}`);
+    return path;
+}
+/**
+ * canon's defaults, then each `standards:` entry in order: a name imports canon's library
+ * standard, a folder adds its files. A later file of the same name replaces an earlier one.
+ */
+export function resolveStandards(canonRoot, entries) {
     const byName = new Map();
-    const sources = [{ dir: join(canonRoot, "standards"), from: "canon" }, ...folders.map((dir) => ({ dir, from: dir }))];
-    for (const { dir, from } of sources) {
-        if (!existsSync(dir))
-            throw new Error(`standards folder not found: ${dir}`);
-        for (const file of markdownIn(dir)) {
-            const name = file.replace(/\.md$/, "");
-            // Constitutions add up (see constitutionTitles), so each one keeps its own entry.
-            const key = name === "constitution" ? `${name}:${from}` : name;
-            byName.set(key, { name, path: join(dir, file), from });
+    const add = (name, path, from) => {
+        // Constitutions add up (see constitutionTitles), so each one keeps its own entry.
+        byName.set(name === "constitution" ? `${name}:${from}` : name, { name, path, from });
+    };
+    const defaults = join(canonRoot, "standards");
+    for (const entry of [defaults, ...entries]) {
+        if (isStandardName(entry)) {
+            add(entry, libraryFile(canonRoot, entry), "canon library");
+            continue;
         }
+        if (!existsSync(entry))
+            throw new Error(`standards folder not found: ${entry}`);
+        const from = entry === defaults ? "canon" : entry;
+        for (const file of markdownIn(entry))
+            add(file.replace(/\.md$/, ""), join(entry, file), from);
     }
     return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name) || Number(a.from !== "canon") - Number(b.from !== "canon"));
 }
 /**
- * Principle headings from canon's constitution and every configured one. A
- * constitution in a folder extends rather than replaces: it adds principles,
- * and restating an ID rewords it.
+ * Principle headings from canon's constitution, every imported library standard
+ * and every configured folder's constitution. They extend rather than replace:
+ * each adds principles, and restating an ID rewords it.
  */
-export function constitutionTitles(canonRoot, folders) {
+export function constitutionTitles(canonRoot, entries) {
     const titles = new Map();
-    for (const dir of [join(canonRoot, "standards"), ...folders]) {
-        const file = join(dir, "constitution.md");
+    const files = [join(canonRoot, "standards"), ...entries].map((entry) => isStandardName(entry) ? libraryFile(canonRoot, entry) : join(entry, "constitution.md"));
+    for (const file of files) {
         if (!existsSync(file))
             continue;
         for (const line of readFileSync(file, "utf8").split("\n")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freetesh/canon",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "canon CLI: keep your domain knowledge and AI rules in your repo, and enforce them.",
   "license": "MIT",
   "author": "Ritesh Firodiya",
@@ -22,6 +22,7 @@
     "packs",
     "templates",
     "scripts/log-verdict.mjs",
+    "scripts/check-designs.py",
     ".claude-plugin"
   ],
   "engines": {