@freetesh/zeno 0.0.0-stage → 0.7.0

package/cli/dist/init.js

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { stringify } from "yaml";
+import { RULES_FILES } from "./checks/architecture.js";
+import { requiredContext } from "./checks/context-layout.js";
+import { inferKind, inferModules } from "./config/load.js";
+import { MODULES_BY_KIND } from "./config/schema.js";
+export const ARCHITECTURE_BASE = ".dependency-cruiser.base.cjs";
+const ARCHITECTURE_TEMPLATES = join("templates", "dependency-cruiser");
+const WORKSPACE_PARENTS = ["apps", "packages"];
+/**
+ * The rules files the architecture module needs: zeno's managed base, then a starter
+ * per workspace (a folder under apps/ or packages/ with a package.json), or one at the
+ * root when the repo has no workspaces.
+ */
+export function architectureStarters(repo) {
+    const workspaces = WORKSPACE_PARENTS.flatMap((parent) => existsSync(join(repo, parent))
+        ? readdirSync(join(repo, parent), { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && existsSync(join(repo, parent, entry.name, "package.json")))
+            .map((entry) => `${parent}/${entry.name}`)
+            .sort()
+        : []);
+    const starters = workspaces.length > 0
+        ? workspaces.map((dir) => ({ file: `${dir}/${RULES_FILES[0]}`, template: dir.startsWith("apps/") ? "app.cjs" : "package.cjs" }))
+        : [{ file: RULES_FILES[0], template: "root.cjs" }];
+    return [{ file: ARCHITECTURE_BASE, template: "base.cjs" }, ...starters];
+}
+/** Rewrites a repo's managed architecture base from zeno's template; true when it changed. */
+export function refreshArchitectureBase(repo, zenoRoot) {
+    const file = join(repo, ARCHITECTURE_BASE);
+    if (!existsSync(file))
+        return false;
+    const current = readFileSync(join(zenoRoot, ARCHITECTURE_TEMPLATES, "base.cjs"), "utf8");
+    if (readFileSync(file, "utf8") === current)
+        return false;
+    writeFileSync(file, current);
+    return true;
+}
+/** Parses a `--modules`/`--packs` style comma list, rejecting anything not in `allowed`. */
+export function parseChoices(value, allowed, label) {
+    const chosen = value.split(",").map((item) => item.trim()).filter(Boolean);
+    const unknown = chosen.find((item) => !allowed.includes(item));
+    if (unknown)
+        throw new Error(`unknown ${label} "${unknown}" — choose from: ${allowed.join(", ")}`);
+    return chosen;
+}
+const PACKAGE_FILES = ["package.json", "apps/mobile/package.json"];
+export function detectExpoSdk(repo) {
+    for (const file of PACKAGE_FILES) {
+        const path = join(repo, file);
+        if (!existsSync(path))
+            continue;
+        const pkg = JSON.parse(readFileSync(path, "utf8"));
+        const range = pkg.dependencies?.expo ?? pkg.devDependencies?.expo;
+        const major = range?.match(/\d+/)?.[0];
+        if (major)
+            return Number(major);
+    }
+    return undefined;
+}
+// The first file each required .context entry gets, so no folder is created empty.
+const FIRST_FILE = {
+    "README.md": ".context/README.md",
+    "tasks.md": ".context/tasks.md",
+    raw: ".context/raw/.gitkeep",
+    wiki: ".context/wiki/index.md",
+    features: ".context/features/index.md",
+};
+function template(file, today) {
+    switch (file) {
+        case ".context/README.md":
+            return "# .context\n\nProduct material, in the ten folders of the zeno context layout.\n\n## Absent folders\n\n- listing/ — n/a — no store presence yet\n- marketing/, metrics/, support/, legal/ — n/a — not live yet\n- ops/ — n/a — nothing to run yet\n";
+        case ".context/tasks.md":
+            return `---\nupdated: ${today}\nhorizon: ${today}\n---\n\n# Tasks\n\n## Now\n\n## Parallel\n\n## Blocked\n\n## Waiting\n\n## Done\n\n## Session Notes\n`;
+        case ".context/wiki/index.md":
+            return "# Wiki index\n\nPages by type. Schema: the zeno plugin's wiki-schema standard.\n";
+        case ".context/features/index.md":
+            return "# Features\n\n| ID | Title | Status | Release |\n|---|---|---|---|\n";
+        default:
+            return "";
+    }
+}
+export function planInit(repo, answers) {
+    if (existsSync(join(repo, ".claude", "zeno.yaml")) && !answers.force) {
+        throw new Error(`${repo} is already set up (.claude/zeno.yaml exists) — use --force to redo it`);
+    }
+    const kind = answers.kind ?? inferKind(repo);
+    const modules = answers.modules ?? (answers.kind ? MODULES_BY_KIND[kind] : inferModules(repo, kind));
+    const sdk = kind === "expo-app" ? detectExpoSdk(repo) : undefined;
+    const packs = answers.packs?.length ? { packs: answers.packs } : {};
+    const config = { zeno: answers.zenoVersion, kind, modules, ...(sdk ? { expo: { sdk } } : {}), ...packs };
+    const create = requiredContext(modules).filter((name) => !existsSync(join(repo, ".context", name))).map((name) => FIRST_FILE[name]);
+    if (modules.includes("architecture")) {
+        // A workspace that already has rules of its own (any name dependency-cruiser reads) keeps them.
+        const taken = (file) => file === ARCHITECTURE_BASE ? existsSync(join(repo, file)) : RULES_FILES.some((name) => existsSync(join(repo, dirname(file), name)));
+        create.push(...architectureStarters(repo).map((s) => s.file).filter((file) => !taken(file)));
+    }
+    return { config, create };
+}
+export function applyInit(repo, plan, options) {
+    const today = options.today ?? new Date().toISOString().slice(0, 10);
+    const write = (file, content) => {
+        mkdirSync(dirname(join(repo, file)), { recursive: true });
+        writeFileSync(join(repo, file), content);
+    };
+    write(".claude/zeno.yaml", stringify(plan.config));
+    const starters = new Map(architectureStarters(repo).map((s) => [s.file, s.template]));
+    for (const file of plan.create) {
+        const starter = starters.get(file);
+        write(file, starter ? readFileSync(join(options.zenoRoot, ARCHITECTURE_TEMPLATES, starter), "utf8") : template(file, today));
+    }
+    if (plan.config.modules.includes("knowledge"))
+        indexKnowledge(repo, options.name, options.run);
+}
+/** Adds the repo's wiki and features to qmd. Safe to repeat: qmd refuses a name it already has. */
+export function indexKnowledge(repo, name, run) {
+    for (const kind of ["wiki", "features"]) {
+        run("qmd", ["collection", "add", join(repo, ".context", kind), "--name", `${name}-${kind}`]);
+    }
+}

package/cli/dist/learn.js

@@ -0,0 +1,69 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+const LOG = join(".context", "raw", "zeno", "verdicts.jsonl");
+const MAX_REASONS = 5;
+function readJsonLines(path) {
+    if (!existsSync(path))
+        return [];
+    return readFileSync(path, "utf8")
+        .split("\n")
+        .flatMap((line) => {
+        try {
+            return line.trim() ? [JSON.parse(line)] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function readVerdicts(repos) {
+    return repos.flatMap((repo) => readJsonLines(join(repo, LOG)).map((entry) => ({ ...entry, product: basename(repo) })));
+}
+function group(entries, keyOf) {
+    const groups = new Map();
+    for (const entry of entries) {
+        for (const key of keyOf(entry))
+            groups.set(key, [...(groups.get(key) ?? []), entry]);
+    }
+    return groups;
+}
+function toProposal(id, summary, entries) {
+    return {
+        id,
+        summary,
+        count: entries.length,
+        products: [...new Set(entries.map((e) => e.product))].sort(),
+        reasons: [...new Set(entries.map((e) => e.reason))].slice(0, MAX_REASONS),
+    };
+}
+/**
+ * Turns override history into proposals: a principle overridden `threshold`+
+ * times, or one reason given in two or more products. A decided proposal comes
+ * back only when its count has grown past what it was when decided.
+ */
+export function proposals(entries, options) {
+    const found = [];
+    for (const [principle, group_] of group(entries, (e) => e.principles)) {
+        if (group_.length >= options.threshold) {
+            found.push(toProposal(`principle:${principle}`, `${principle} was overridden ${group_.length} times — revisit the rule or its wording`, group_));
+        }
+    }
+    for (const [reason, group_] of group(entries, (e) => [e.reason])) {
+        const products = new Set(group_.map((e) => e.product));
+        if (products.size >= 2) {
+            found.push(toProposal(`reason:${reason}`, `"${reason}" was given in ${products.size} products — a missing exception?`, group_));
+        }
+    }
+    const decidedAt = new Map(options.decisions.map((d) => [d.id, d.count]));
+    return found.filter((p) => !decidedAt.has(p.id) || p.count > (decidedAt.get(p.id) ?? 0));
+}
+// In the estate, not the zeno install: a global npm install may be read-only and is replaced on upgrade.
+const DECISIONS_DIR = join(".claude", "zeno");
+const DECISIONS = join(DECISIONS_DIR, "decisions.jsonl");
+export function readDecisions(estateRoot) {
+    return readJsonLines(join(estateRoot, DECISIONS));
+}
+export function recordDecision(estateRoot, decision) {
+    mkdirSync(join(estateRoot, DECISIONS_DIR), { recursive: true });
+    appendFileSync(join(estateRoot, DECISIONS), `${JSON.stringify({ ...decision, at: new Date().toISOString() })}\n`);
+}

package/cli/dist/lib/files.js

@@ -0,0 +1,23 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+/** Every file under `dir` whose name matches `test`, as paths relative to `root`. Missing dir → []. */
+export function listFiles(root, dir, test) {
+    const start = join(root, dir);
+    if (!existsSync(start))
+        return [];
+    const found = [];
+    const walk = (current) => {
+        for (const entry of readdirSync(current, { withFileTypes: true })) {
+            const full = join(current, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (test(entry.name))
+                found.push(relative(root, full));
+        }
+    };
+    walk(start);
+    return found.sort();
+}
+export function isDirectory(path) {
+    return existsSync(path) && statSync(path).isDirectory();
+}

package/cli/dist/lib/frontmatter.js

@@ -0,0 +1,16 @@
+import { parse } from "yaml";
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+/** Splits YAML frontmatter from a Markdown body. Unparseable or absent frontmatter → data null. */
+export function parseFrontmatter(text) {
+    const match = FRONTMATTER.exec(text);
+    if (!match)
+        return { data: null, body: text };
+    try {
+        const data = parse(match[1]);
+        const isObject = typeof data === "object" && data !== null && !Array.isArray(data);
+        return { data: isObject ? data : null, body: text.slice(match[0].length) };
+    }
+    catch {
+        return { data: null, body: text.slice(match[0].length) };
+    }
+}

package/cli/dist/lib/system.js

@@ -0,0 +1,19 @@
+import { spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const CACHE_DIR = process.env.ZENO_CACHE ?? join(homedir(), ".cache", "zeno");
+const FETCH_TIMEOUT_MS = 30_000;
+export function runCommand(command, args) {
+    const result = spawnSync(command, args, { encoding: "utf8" });
+    if (result.error) {
+        const missing = result.error.code === "ENOENT";
+        return { status: 1, output: missing ? `${command} is not installed — run \`zeno doctor\`` : result.error.message };
+    }
+    return { status: result.status ?? 1, output: `${result.stdout}${result.stderr}` };
+}
+export async function fetchText(url) {
+    const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+    return response.text();
+}

package/cli/dist/packs.js

@@ -0,0 +1,85 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse, parseDocument } from "yaml";
+import { z } from "zod";
+import { KINDS } from "./config/schema.js";
+const packSchema = z
+    .object({
+    name: z.string().regex(/^[a-z0-9-]+$/),
+    description: z.string(),
+    kinds: z.array(z.enum(KINDS)),
+    skill: z.string().optional(),
+    docs: z.array(z.url()),
+})
+    .strict();
+export function listPacks(zenoRoot) {
+    const root = join(zenoRoot, "packs");
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, "pack.yaml")))
+        .map((entry) => {
+        const pack = packSchema.parse(parse(readFileSync(join(root, entry.name, "pack.yaml"), "utf8")));
+        if (pack.name !== entry.name)
+            throw new Error(`packs/${entry.name}/pack.yaml is named "${pack.name}"`);
+        return pack;
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function findPack(zenoRoot, name) {
+    const packs = listPacks(zenoRoot);
+    const pack = packs.find((candidate) => candidate.name === name);
+    if (!pack)
+        throw new Error(`no pack "${name}" — available: ${packs.map((p) => p.name).join(", ")}`);
+    return pack;
+}
+/** Records a pack in zeno.yaml (product, or estate with --global), keeping the file's comments and other keys. */
+export function addPack(repo, name, options) {
+    findPack(options.zenoRoot, name);
+    if (options.global && !options.estateRoot)
+        throw new Error("--global needs an estate (a folder whose zeno.yaml says estate: true)");
+    const base = options.global ? options.estateRoot : repo;
+    const file = join(base, ".claude", "zeno.yaml");
+    if (!existsSync(file) && !options.global)
+        throw new Error(`${repo} has no .claude/zeno.yaml — run \`zeno init\` first`);
+    const document = parseDocument(existsSync(file) ? readFileSync(file, "utf8") : "");
+    const current = document.get("packs")?.toJSON() ?? [];
+    if (current.includes(name))
+        return { file, added: false };
+    document.set("packs", [...current, name]);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, document.toString());
+    return { file, added: true };
+}
+function docFileName(url) {
+    const { hostname, pathname } = new URL(url);
+    const stem = pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z]+$/, "") ?? "index";
+    return `${hostname}-${stem}.md`;
+}
+/** Downloads a pack's vendor docs into the cache as Markdown and indexes them in QMD as `pack-<name>`. */
+export async function fetchPackDocs(pack, options) {
+    const dir = join(options.cacheDir, "packs", pack.name);
+    mkdirSync(dir, { recursive: true });
+    for (const url of pack.docs) {
+        let text;
+        try {
+            text = await options.fetchText(url);
+        }
+        catch (error) {
+            throw new Error(`could not download ${url}: ${error.message}`);
+        }
+        writeFileSync(join(dir, docFileName(url)), text);
+    }
+    const collection = `pack-${pack.name}`;
+    const added = options.run("qmd", ["collection", "add", dir, "--name", collection]);
+    if (added.status === 0) {
+        options.run("qmd", ["context", "add", `qmd://${collection}`, `${pack.description.split(" — ")[0]} — vendor docs index (${pack.name} pack)`]);
+    }
+    else if (/already exists/i.test(added.output)) {
+        options.run("qmd", ["update"]);
+    }
+    else {
+        throw new Error(`qmd could not index ${dir}: ${added.output.trim()}`);
+    }
+    return dir;
+}

package/cli/dist/run.js

@@ -0,0 +1,45 @@
+import { existsSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+import { ALL_CHECKS } from "./checks/index.js";
+import { loadConfig } from "./config/load.js";
+import { isDirectory } from "./lib/files.js";
+export function runChecks(repo, options) {
+    const report = { repo, name: basename(repo), findings: [], skipped: [], overrides: [] };
+    if (!isDirectory(repo)) {
+        report.findings.push({ check: "repo", level: "error", message: `no folder at ${repo}` });
+        return report;
+    }
+    let config;
+    try {
+        config = loadConfig(repo, { estateRoot: options.estateRoot }).config;
+    }
+    catch (error) {
+        report.findings.push({ check: "config", level: "error", message: error.message });
+        return report;
+    }
+    for (const check of options.checks ?? ALL_CHECKS) {
+        const override = config.checks[check.id];
+        if (override && !override.enabled) {
+            report.overrides.push({ check: check.id, reason: override.reason ?? "" });
+            continue;
+        }
+        if (check.module && !config.modules.includes(check.module)) {
+            report.skipped.push({ check: check.id, why: `module ${check.module} is off` });
+            continue;
+        }
+        try {
+            report.findings.push(...check.run({ repo, name: report.name, config, zenoRoot: options.zenoRoot, today: options.today ?? new Date() }));
+        }
+        catch (error) {
+            report.findings.push({ check: check.id, level: "error", message: `check crashed: ${error.message}` });
+        }
+    }
+    return report;
+}
+/** Product repos in the estate: every direct child folder holding a .context/. */
+export function findProducts(estateRoot) {
+    return readdirSync(estateRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && existsSync(join(estateRoot, entry.name, ".context")))
+        .map((entry) => join(estateRoot, entry.name))
+        .sort();
+}

package/cli/dist/standards.js

@@ -0,0 +1,42 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+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));
+}
+/** zeno's default standards, then each configured folder in order; a later file of the same name replaces an earlier one. */
+export function resolveStandards(zenoRoot, folders) {
+    const byName = new Map();
+    const sources = [{ dir: join(zenoRoot, "standards"), from: "zeno" }, ...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 });
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name) || Number(a.from !== "zeno") - Number(b.from !== "zeno"));
+}
+/**
+ * Principle headings from zeno's constitution and every configured one. A
+ * constitution in a folder extends rather than replaces: it adds principles,
+ * and restating an ID rewords it.
+ */
+export function constitutionTitles(zenoRoot, folders) {
+    const titles = new Map();
+    for (const dir of [join(zenoRoot, "standards"), ...folders]) {
+        const file = join(dir, "constitution.md");
+        if (!existsSync(file))
+            continue;
+        for (const line of readFileSync(file, "utf8").split("\n")) {
+            const match = PRINCIPLE.exec(line);
+            if (match)
+                titles.set(match[1], `${match[1]} ${match[2]}`);
+        }
+    }
+    return [...titles.values()];
+}

package/cli/dist/status.js

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig } from "./config/load.js";
+import { runChecks } from "./run.js";
+export function zenoVersion(zenoRoot) {
+    const manifest = join(zenoRoot, ".claude-plugin", "plugin.json");
+    if (!existsSync(manifest))
+        return "unknown";
+    return JSON.parse(readFileSync(manifest, "utf8")).version ?? "unknown";
+}
+export function buildStatus(repo, options) {
+    const { config, sources } = loadConfig(repo, { estateRoot: options.estateRoot });
+    const report = runChecks(repo, options);
+    const errors = report.findings.filter((f) => f.level === "error").length;
+    const warnings = report.findings.length - errors;
+    const configLine = sources.length === 0
+        ? "none — inferred; run `zeno init`"
+        : sources.map((source) => `${source.layer} ${source.path}`).join("\n         ");
+    return [
+        `zeno ${zenoVersion(options.zenoRoot)}  ·  ${report.name}`,
+        `kind     ${config.kind}`,
+        `modules  ${config.modules.join(", ")}`,
+        `config   ${configLine}`,
+        `checks   ${errors} error${errors === 1 ? "" : "s"}, ${warnings} warning${warnings === 1 ? "" : "s"}` +
+            (report.overrides.length > 0 ? `, ${report.overrides.length} override(s)` : ""),
+    ].join("\n");
+}

package/cli/dist/sync.js

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { parseDocument } from "yaml";
+import { loadConfig } from "./config/load.js";
+import { indexKnowledge, refreshArchitectureBase } from "./init.js";
+import { fetchPackDocs, findPack } from "./packs.js";
+import { zenoVersion } from "./status.js";
+/** Refreshes a product's pack docs and search index, and moves its pinned zeno version to the current one. */
+export async function syncRepo(repo, options) {
+    const file = join(repo, ".claude", "zeno.yaml");
+    if (!existsSync(file))
+        throw new Error(`${repo} has no .claude/zeno.yaml — run \`zeno init\` first`);
+    const { config } = loadConfig(repo, { estateRoot: options.estateRoot });
+    const packs = config.packs;
+    for (const name of packs) {
+        await fetchPackDocs(findPack(options.zenoRoot, name), options);
+    }
+    if (config.modules.includes("knowledge"))
+        indexKnowledge(repo, basename(repo), options.run);
+    options.run("qmd", ["update"]);
+    options.run("qmd", ["embed"]);
+    const base = refreshArchitectureBase(repo, options.zenoRoot);
+    const current = zenoVersion(options.zenoRoot);
+    if (config.zeno === current)
+        return { packs, base, version: null };
+    const document = parseDocument(readFileSync(file, "utf8"));
+    document.set("zeno", current);
+    writeFileSync(file, document.toString());
+    return { packs, base, version: { from: config.zeno, to: current } };
+}

package/cli/dist/ui.js

@@ -0,0 +1,69 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { parseDocument } from "yaml";
+const SURFACES = ["mobile", "web"];
+function relink(target, link) {
+    rmSync(link, { force: true, recursive: false });
+    symlinkSync(target, link);
+}
+// routes.js comes in two styles (`architecture: "…"` and `"architecture": "…"`);
+// a regex reads both without executing the manifest.
+const ARCHITECTURE_KEY = /["']?architecture["']?\s*:\s*["']([^"']+)["']/;
+/** The views a drawn surface offers — flow chart, screenshots, architecture — as relative paths that exist. */
+function surfaceViews(designs, surface) {
+    const dir = join(designs, surface);
+    if (!existsSync(join(dir, "index.html")))
+        return [];
+    const views = [["flow chart", "index.html"]];
+    if (existsSync(join(dir, "screenshots.html")))
+        views.push(["screenshots", "screenshots.html"]);
+    const routes = join(dir, "routes.js");
+    const architecture = existsSync(routes) ? ARCHITECTURE_KEY.exec(readFileSync(routes, "utf8"))?.[1] : undefined;
+    if (architecture && existsSync(join(dir, architecture)))
+        views.push(["architecture", architecture]);
+    return views.map(([label, path]) => [label, `${surface}/${path}`]);
+}
+/** Lays out the content Quartz renders and the folder the design server serves. */
+export function buildSite(products, options) {
+    mkdirSync(options.siteDir, { recursive: true });
+    mkdirSync(options.designsDir, { recursive: true });
+    const rows = [];
+    for (const product of products) {
+        const name = basename(product);
+        const wiki = join(product, ".context", "wiki");
+        const designs = join(product, ".context", "designs");
+        const links = [];
+        if (existsSync(wiki)) {
+            relink(wiki, join(options.siteDir, name));
+            links.push(`[[${name}/index|${name}]]`);
+        }
+        const graph = options.graph?.(product);
+        if (graph) {
+            mkdirSync(join(options.siteDir, "architecture"), { recursive: true });
+            writeFileSync(join(options.siteDir, "architecture", `${name}.md`), `---\ntitle: ${name} architecture\n---\n\nImports between parts of ${name}, from its \`.dependency-cruiser.cjs\`. Broken rules fail \`zeno check\`.\n\n${graph}\n`);
+            links.push(`[[architecture/${name}|architecture graph]]`);
+        }
+        const surfaces = SURFACES.map((surface) => [surface, surfaceViews(designs, surface)]).filter(([, views]) => views.length > 0);
+        if (surfaces.length > 0)
+            relink(designs, join(options.designsDir, name));
+        if (links.length > 0 || surfaces.length > 0)
+            rows.push(`- ${links.join(" · ") || name}`);
+        for (const [surface, views] of surfaces) {
+            const linked = views.map(([label, path]) => `[${label}](${options.designsUrl}/${name}/${path})`);
+            rows.push(`  - ${surface}: ${linked.join(" · ")}`);
+        }
+    }
+    writeFileSync(join(options.siteDir, "index.md"), `---\ntitle: zeno\n---\n\nEvery product's wiki, searchable and linked. Each surface opens its flow chart, screenshots and architecture overview; products with architecture rules also get an import graph.\n\n${rows.join("\n")}\n\n[[zeno-check|Standards check]]\n`);
+    writeFileSync(join(options.siteDir, "zeno-check.md"), `---\ntitle: Standards check\n---\n\nOutput of \`zeno check --all\` when this site was built.\n\n\`\`\`\n${options.report}\n\`\`\`\n`);
+}
+const IGNORED = ["**/CLAUDE.md", "_designs"];
+/** Quartz's default config, adjusted for a private local site: no analytics, no schema files as pages. */
+export function quartzConfig(defaultsYaml) {
+    const document = parseDocument(defaultsYaml);
+    document.setIn(["configuration", "pageTitle"], "zeno");
+    document.setIn(["configuration", "analytics"], null);
+    document.setIn(["configuration", "baseUrl"], "localhost");
+    const current = document.getIn(["configuration", "ignorePatterns"])?.toJSON() ?? [];
+    document.setIn(["configuration", "ignorePatterns"], [...current, ...IGNORED.filter((p) => !current.includes(p))]);
+    return document.toString();
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@freetesh/zeno",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.7.0",
+  "description": "zeno CLI: set up, check and sync product repos against the shared standards.",
+  "license": "MIT",
+  "author": "Ritesh Firodiya",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ritesh-firodiya/zeno-ai.git"
+  },
+  "type": "module",
+  "bin": {
+    "zeno": "cli/dist/index.js"
+  },
+  "files": [
+    "cli/dist",
+    "standards",
+    "skills",
+    "packs",
+    "templates",
+    ".claude-plugin"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "pnpm@12.3.4",
+  "scripts": {
+    "zeno": "node cli/src/index.ts",
+    "build": "rm -rf cli/dist && tsc -p cli/tsconfig.build.json",
+    "test": "vitest run --root cli",
+    "coverage": "vitest run --root cli --coverage",
+    "typecheck": "tsc -p cli",
+    "prepack": "pnpm build",
+    "release": "bash scripts/publish.sh"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "commander": "^15.0.0",
+    "yaml": "^2.9.1",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "@vitest/coverage-v8": "^5.0.5",
+    "dependency-cruiser": "18.7.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packs/expo/pack.yaml

@@ -0,0 +1,5 @@
+name: expo
+description: Expo / React Native — versioned SDK docs
+kinds: [expo-app]
+docs:
+  - https://docs.expo.dev/llms.txt

package/packs/firebase/pack.yaml

@@ -0,0 +1,5 @@
+name: firebase
+description: Firebase — auth, Firestore, rules, functions
+kinds: [expo-app, web]
+docs:
+  - https://firebase.google.com/docs/llms.txt

package/packs/nextjs/pack.yaml

@@ -0,0 +1,5 @@
+name: nextjs
+description: Next.js — app router, server components, routing
+kinds: [web]
+docs:
+  - https://nextjs.org/docs/llms.txt

package/packs/react/pack.yaml

@@ -0,0 +1,5 @@
+name: react
+description: React — components, hooks, rendering
+kinds: [expo-app, web]
+docs:
+  - https://react.dev/llms.txt

package/packs/revenuecat/pack.yaml

@@ -0,0 +1,5 @@
+name: revenuecat
+description: RevenueCat — subscriptions, paywalls, entitlements
+kinds: [expo-app, web]
+docs:
+  - https://www.revenuecat.com/docs/llms.txt

package/packs/uniwind/pack.yaml

@@ -0,0 +1,5 @@
+name: uniwind
+description: UniWind — Tailwind classes for React Native
+kinds: [expo-app]
+docs:
+  - https://docs.uniwind.dev/llms.txt