@takodotid/circuit 0.43.1 → 1.0.0-rc.2

package/src/cli/editor-types.ts

@@ -0,0 +1,69 @@
+// The files a project's editor reads, in `.circuit/types/`: Circuit's functions and types, so a project's files complete and check with nothing installed.
+
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { EDITOR_FILES } from "./editor-types.generated";
+
+export class EditorTypes {
+    /** Where they go, in the project. */
+    static readonly FOLDER = join(".circuit", "types");
+
+    /** The project's `tsconfig.json`: Circuit writes it when it starts a project. It reads Circuit's globals, and `circuit` for `import type` in `lib/`. */
+    static readonly TSCONFIG = `${JSON.stringify(
+        {
+            compilerOptions: {
+                strict: true,
+                noEmit: true,
+                target: "ES2022",
+                module: "ESNext",
+                moduleResolution: "bundler",
+                skipLibCheck: true,
+                types: [],
+                paths: { circuit: ["./.circuit/types/config/index.ts"] },
+            },
+            include: ["**/*.ts", ".circuit/types/config/circuit.d.ts"],
+        },
+        null,
+        4
+    )}\n`;
+
+    /** A full install's `tsconfig.json`: the types come from the Circuit package in `node_modules`, so the project has no `.circuit/types`. */
+    static readonly TSCONFIG_FULL = `${JSON.stringify(
+        {
+            compilerOptions: {
+                strict: true,
+                noEmit: true,
+                target: "ES2022",
+                module: "ESNext",
+                moduleResolution: "bundler",
+                skipLibCheck: true,
+                types: [],
+                paths: { circuit: ["./node_modules/@takodotid/circuit/src/config/index.ts"] },
+            },
+            include: ["**/*.ts", "node_modules/@takodotid/circuit/src/config/circuit.d.ts"],
+            exclude: ["node_modules/@takodotid/circuit/src/cli", "node_modules/@takodotid/circuit/src/studio"],
+        },
+        null,
+        4
+    )}\n`;
+
+    /** Writes every file again, removing the old ones first. */
+    static write(root: string): void {
+        const folder = join(root, EditorTypes.FOLDER);
+        rmSync(folder, { recursive: true, force: true });
+
+        for (const [path, text] of Object.entries(EDITOR_FILES)) {
+            mkdirSync(dirname(join(folder, path)), { recursive: true });
+            writeFileSync(join(folder, path), text);
+        }
+    }
+
+    /** Whether the project's types are this Circuit's: every file as this Circuit writes it. No version is kept beside them: the project's version is `.circuit/version`, and the files themselves say whether they are current. */
+    static current(root: string): boolean {
+        const folder = join(root, EditorTypes.FOLDER);
+        return Object.entries(EDITOR_FILES).every(([path, text]) => {
+            const file = join(folder, path);
+            return existsSync(file) && readFileSync(file, "utf8") === text;
+        });
+    }
+}

package/src/cli/format.ts

@@ -0,0 +1,124 @@
+// `circuit fmt`: the project's files in its style. It is Prettier, carried inside Circuit, so nothing else is installed. The style is Prettier's own, set by the project's `.editorconfig` (indent, line length, line ends), as VS Code's Prettier extension reads it, so saving in the editor and `circuit fmt` agree. A `.prettierrc.json`, when a project adds one, goes on top, for both.
+
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import * as estree from "prettier/plugins/estree";
+import * as typescript from "prettier/plugins/typescript";
+import * as babel from "prettier/plugins/babel";
+import type { Options } from "prettier";
+import { format } from "prettier/standalone";
+import { Ui } from "./ui";
+
+export class Format {
+    /** What a new project's `.editorconfig` says: four spaces, lines up to 140, LF. */
+    static readonly EDITORCONFIG =
+        "root = true\n\n[*]\ncharset = utf-8\nend_of_line = lf\ninsert_final_newline = true\nindent_style = space\nindent_size = 4\nmax_line_length = 140\n";
+
+    /** Folders that hold nothing of the project's own to format. */
+    private static readonly SKIPPED = new Set(["node_modules", ".git", ".circuit", "dist"]);
+
+    /** The settings of `.editorconfig` that apply to a TypeScript file: those under `[*]`, then under a section that names `.ts`. */
+    static editorconfig(text: string): Record<string, string> {
+        const settings: Record<string, string> = {};
+        let applies = false;
+
+        for (const raw of text.split(/\r?\n/)) {
+            const line = raw.replace(/[#;].*$/, "").trim();
+            const section = /^\[(.+)\]$/.exec(line);
+            if (section) {
+                applies = section[1] === "*" || /\bts\b/.test(section[1]!);
+                continue;
+            }
+
+            const [key, value] = line.split("=").map((part) => part.trim());
+            if (applies && key && value) settings[key.toLowerCase()] = value.toLowerCase();
+        }
+
+        return settings;
+    }
+
+    /** The project's style: Prettier's own, then what `.editorconfig` sets, mapped as Prettier's `editorConfigToPrettier` maps it, then a `.prettierrc.json` if the project has one. */
+    static style(root: string): Options {
+        const style: Options = {};
+        const editorconfig = join(root, ".editorconfig");
+
+        if (existsSync(editorconfig)) {
+            const settings = Format.editorconfig(readFileSync(editorconfig, "utf8"));
+            const whole = (value: string | undefined) => (value && /^[1-9]\d*$/.test(value) ? Number(value) : undefined);
+
+            // What the EditorConfig library fills in before Prettier reads the settings.
+            if (settings.indent_style === "tab" && !settings.indent_size) settings.indent_size = "tab";
+            if (settings.indent_size && !settings.tab_width && settings.indent_size !== "tab") settings.tab_width = settings.indent_size;
+            if (settings.indent_size === "tab" && settings.tab_width) settings.indent_size = settings.tab_width;
+
+            if (settings.indent_style === "space") style.useTabs = false;
+            else if (settings.indent_style === "tab" || settings.indent_size === "tab") style.useTabs = true;
+
+            const width = style.useTabs === false && whole(settings.indent_size) ? whole(settings.indent_size) : whole(settings.tab_width);
+            if (width) style.tabWidth = width;
+
+            if (settings.max_line_length === "off") style.printWidth = Number.POSITIVE_INFINITY;
+            else if (whole(settings.max_line_length)) style.printWidth = whole(settings.max_line_length);
+
+            if (settings.quote_type === "single") style.singleQuote = true;
+            else if (settings.quote_type === "double") style.singleQuote = false;
+
+            if (settings.end_of_line === "lf" || settings.end_of_line === "crlf" || settings.end_of_line === "cr")
+                style.endOfLine = settings.end_of_line;
+        }
+
+        const own = join(root, ".prettierrc.json");
+        return existsSync(own) ? { ...style, ...(JSON.parse(readFileSync(own, "utf8")) as Options) } : style;
+    }
+
+    /** Every TypeScript file of the project, relative to it. A JSON file is formatted only when named. */
+    static files(root: string, directory = root): string[] {
+        return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+            if (entry.isDirectory()) return Format.SKIPPED.has(entry.name) ? [] : Format.files(root, join(directory, entry.name));
+            return entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") ? [relative(root, join(directory, entry.name))] : [];
+        });
+    }
+
+    /** A file's text in the style. */
+    static async text(text: string, file: string, style: Options): Promise<string> {
+        const parser = file.endsWith(".json") ? "json" : "typescript";
+        return format(text, { ...style, parser, plugins: [estree, typescript, babel] });
+    }
+
+    /** Format the files named, or every file of the project. With `check`, change nothing and exit 1 when a file is not in the style. */
+    static async run(root: string, named: readonly string[], check: boolean): Promise<void> {
+        const style = Format.style(root);
+        const files = named.length ? named.map((file) => relative(root, resolve(process.cwd(), file))) : Format.files(root);
+        const off: string[] = [];
+
+        await Ui.wait(`Reading ${files.length} file(s)`, async () => {
+            for (const file of files) {
+                const path = join(root, file);
+                const before = readFileSync(path, "utf8");
+                let after: string;
+                try {
+                    after = await Format.text(before, file, style);
+                } catch (error) {
+                    Ui.fail(`${file}: ${(error as Error).message.split("\n")[0]}`);
+                }
+
+                if (after === before) continue;
+                off.push(file);
+                if (!check) writeFileSync(path, after);
+            }
+        });
+
+        if (check) {
+            for (const file of off) Ui.warn(`${file} is not in the project's style`);
+            if (off.length) Ui.fail(`\n${off.length} file(s) to tidy: run circuit fmt.`);
+            Ui.done(`${files.length} file(s), all in style.`);
+            return;
+        }
+
+        Ui.done(
+            off.length
+                ? `Tidied ${off.length} of ${files.length} file(s): spacing and line breaks only.`
+                : `${files.length} file(s), all in style already.`
+        );
+    }
+}

package/src/cli/git-hooks.ts

@@ -0,0 +1,79 @@
+// The git hook a project runs before each commit, whatever makes the commit: a terminal, VS Code or GitHub Desktop. The hook is a file in `.circuit/hooks`, committed with the project, that calls `circuit hook pre-commit`. git finds it through `core.hooksPath`, a setting a clone does not carry, so Circuit sets it each time it runs in a project that lacks it.
+
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { SecretsFile } from "../core/secrets-file";
+
+export class GitHooks {
+    /** Where the hooks are, in the project. */
+    static readonly FOLDER = ".circuit/hooks";
+
+    static readonly PRE_COMMIT = `#!/bin/sh
+# Written by Circuit. Before each commit: every secret encrypted, and a project that validates.
+if ! command -v circuit >/dev/null 2>&1; then
+    echo "Circuit is not installed here, so this commit was not checked and was stopped. Install Circuit: https://circuit.tako.id" >&2
+    exit 1
+fi
+exec circuit hook pre-commit
+`;
+
+    private static git(root: string, args: string[]): { ok: boolean; out: string } {
+        // `env` given, so a change to process.env reaches git: Bun passes its starting environment otherwise.
+        const result = spawnSync("git", ["-C", root, ...args], { encoding: "utf8", env: process.env });
+        return { ok: !result.error && result.status === 0, out: result.stdout ?? "" };
+    }
+
+    static gitInstalled(): boolean {
+        return !spawnSync("git", ["--version"], { encoding: "utf8" }).error;
+    }
+
+    /** The folder is in a git repository. */
+    static isRepository(root: string): boolean {
+        return GitHooks.git(root, ["rev-parse", "--git-dir"]).ok;
+    }
+
+    /** Start a repository on `main`. */
+    static init(root: string): void {
+        if (!GitHooks.git(root, ["init", "--initial-branch=main"]).ok) throw new Error("git could not start a repository here");
+    }
+
+    /**
+     * Write the hook and point git at it, in a git repository. Gives back what changed, to tell the person, or undefined when nothing did. A repository that sends its hooks elsewhere, such as to husky, is left alone.
+     */
+    static install(root: string): string | undefined {
+        if (!GitHooks.isRepository(root)) return undefined;
+
+        const path = join(root, GitHooks.FOLDER, "pre-commit");
+        const changes: string[] = [];
+
+        if (!existsSync(path) || readFileSync(path, "utf8") !== GitHooks.PRE_COMMIT) {
+            mkdirSync(join(root, GitHooks.FOLDER), { recursive: true });
+            writeFileSync(path, GitHooks.PRE_COMMIT);
+            changes.push(`wrote ${GitHooks.FOLDER}/pre-commit`);
+        }
+
+        // A clone on Linux or macOS takes the file without its execute bit when it was committed from Windows.
+        if (process.platform !== "win32") chmodSync(path, 0o755);
+
+        const current = GitHooks.git(root, ["config", "--get", "core.hooksPath"]).out.trim();
+        if (!current) {
+            GitHooks.git(root, ["config", "core.hooksPath", GitHooks.FOLDER]);
+            changes.push("git now checks each commit for secrets in plain text");
+        }
+
+        return changes.length ? changes.join(", ") : undefined;
+    }
+
+    /** Problems with the secrets files staged, `files` relative to the project: a value in plain text, or a password written as itself. Empty when the commit may go on. */
+    static stagedProblems(root: string, files: readonly string[]): string[] {
+        const top = GitHooks.git(root, ["rev-parse", "--show-toplevel"]).out.trim();
+        const prefix = GitHooks.git(root, ["rev-parse", "--show-prefix"]).out.trim();
+        const wanted = new Set(files.map((file) => `${prefix}${file.replace(/\\/g, "/")}`));
+        const staged = GitHooks.git(root, ["diff", "--cached", "--name-only", "--diff-filter=ACMR"]).out.split("\n").filter(Boolean);
+
+        return staged
+            .filter((file) => wanted.has(file))
+            .flatMap((file) => SecretsFile.problemsIn(GitHooks.git(top || root, ["show", `:${file}`]).out, file));
+    }
+}