@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/dist/src/verbs/version.js

@@ -1,7 +1,18 @@
-import { CONTRACT_VERSION } from "../version.js";
-import { EXIT_CLEAN } from "./verb.js";
+import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.js";
+import { productFault } from "../failure.js";
+import {} from "./verb.js";
+import { message, PRODUCT } from "../product.js";
+/** The version the host reports for this analyzer; one it cannot read is a fault of the analyzer. */
+export function ownVersion(host) {
+    try {
+        return host.analyzerVersion();
+    }
+    catch (error) {
+        throw productFault(`cannot read its own version: ${message(error)}`);
+    }
+}
 /** Writes the version the host reports and the Contract version this analyzer implements. */
 export const versionVerb = ({ out, host }) => {
-    out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+    out.write(`${PRODUCT} ${ownVersion(host)}\ncontract ${CONTRACT_VERSION}\n`);
     return EXIT_CLEAN;
 };

package/dist/src/workflow-steps.js

@@ -1,41 +1,55 @@
 /**
- * The source files a CI workflow's `run:` steps name by their path from the target root.
- * A workflow file is read as text, line by line, with no YAML parsed.
+ * The source files a CI workflow's `run:` steps and the repository's git hooks name by their
+ * path from the target root. A workflow or hook file is read as text, line by line, with no
+ * YAML parsed.
  */
-import { scriptTokens } from "./manifest.js";
-import { joinPath, resolvePath } from "./paths.js";
+import { joinPath, relativePath, resolvePath } from "./paths.js";
+import { filesIn } from "./fs/tree.js";
+import { commandsOf, scriptTokens, unquoted, withoutComment } from "./text/shell.js";
 const WORKFLOWS = ".github/workflows";
 /** A line holding a run command: indentation and one sequence marker before `run:`. */
 const RUN_LINE = /^(\s*(?:- )?)run:(.*)$/u;
+/** The directories whose every file is a git hook script, run as the shell runs it. */
+const HOOK_DIRS = [".husky", ".githooks"];
+/** A line setting the directory a workflow step, or each step a `defaults.run` covers, runs in. */
+const WORKING_DIRECTORY = /^(\s*(?:- )?)working-directory:(.*)$/u;
+const LEFTHOOK_FILES = ["lefthook.yml", "lefthook.yaml", ".lefthook.yml"];
+/** A line setting the directory a lefthook command runs in. */
+const LEFTHOOK_ROOT = /^(\s*(?:- )?)root:(.*)$/u;
+/** The hook manager files whose commands are written under a key, with that key. */
+const HOOK_MANAGERS = [
+    [".pre-commit-config.yaml", /^(\s*(?:- )?)entry:(.*)$/u],
+    ...LEFTHOOK_FILES.map((name) => [name, RUN_LINE]),
+];
+/** The names GNU make reads a makefile under, in the order it tries them. */
+const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"];
 const BLOCK_SCALAR = /^[|>][+-]?$/u;
-const QUOTED = /^(["'])(.*)\1$/su;
 /** A token holding one of these is computed or a pattern, so it names no file. */
 const COMPUTED = /[${*?[]/u;
 const INDENT = /^\s*/u;
-function workflowFiles(host, dir) {
-    let entries;
+/** The files directly in one directory whose name `accepts`, by path in name order. */
+function pathsIn(host, dir, accepts) {
+    return filesIn(host, dir, accepts).map((name) => joinPath(dir, name));
+}
+function readText(host, path) {
     try {
-        entries = host.readDirectory(dir);
+        return host.readFile(path);
     }
     catch {
-        return [];
+        return undefined;
     }
-    return entries
-        .filter((entry) => !entry.directory && /\.ya?ml$/u.test(entry.name))
-        .map((entry) => joinPath(dir, entry.name))
-        .sort();
 }
-/** Every command line one workflow file's `run:` steps hold. */
-export function runCommands(text) {
+/** Every line one workflow file's `run:` steps hold, or every line of the values written under `key`. */
+export function runCommands(text, key = RUN_LINE) {
     const lines = text.split(/\r?\n/u);
     const found = [];
     for (let at = 0; at < lines.length; at += 1) {
-        const match = RUN_LINE.exec(lines[at] ?? "");
+        const match = key.exec(lines[at] ?? "");
         if (match === null) {
             continue;
         }
         const column = (match[1] ?? "").length;
-        const value = (match[2] ?? "").trim().replace(QUOTED, "$2");
+        const value = unquoted((match[2] ?? "").trim());
         if (!BLOCK_SCALAR.test(value)) {
             found.push(value);
             continue;
@@ -50,28 +64,99 @@ export function runCommands(text) {
     }
     return found;
 }
-/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
-export function workflowTokens(host, targetRoot) {
-    const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
+/**
+ * The commands of the recipe lines of the target root's makefile, each line's in order: a
+ * recipe line is one that starts with a tab, joined with the lines a trailing `\`
+ * continues it onto.
+ */
+function recipeLines(host, root) {
+    const path = MAKEFILES.map((name) => joinPath(root, name)).find((candidate) => host.kindOf(candidate) === "file");
+    const text = path === undefined ? undefined : readText(host, path);
+    if (text === undefined) {
+        return [];
+    }
+    return text
+        .replace(/\\\r?\n/gu, " ")
+        .split(/\r?\n/u)
+        .filter((line) => line.startsWith("\t"))
+        .map((line) => commandsOf(withoutComment(line.slice(1).replace(/^[@+-]+/u, ""))));
+}
+/**
+ * Every token the recipe lines of the target root's makefile hold, each with the directory
+ * below the root it is read against: make runs each line in a shell of its own, so a `cd`
+ * moves the directory of the later commands of its line alone.
+ */
+function recipeTokens(host, root) {
     const found = [];
-    for (const path of workflowFiles(host, dir)) {
-        let text;
-        try {
-            text = host.readFile(path);
-        }
-        catch {
-            continue;
-        }
-        for (const command of runCommands(text)) {
-            found.push(...scriptTokens(command));
+    for (const line of recipeLines(host, root)) {
+        let dir = root;
+        for (const command of line) {
+            const tokens = scriptTokens(command);
+            const [first, target, ...rest] = tokens;
+            if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
+                dir = resolvePath(dir, target);
+                continue;
+            }
+            for (const token of tokens) {
+                found.push({ token, dir: relativePath(root, dir) ?? "" });
+            }
         }
     }
     return found;
 }
 /**
- * The own files the `run:` steps of every workflow file in the target root's
- * `.github/workflows` name: a token equal to a file's path below the target root, with or
- * without a leading `./`, whatever directory the step runs in.
+ * Every command the target root's workflow steps, git hooks and makefile run: the `run:`
+ * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
+ * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
+ * of a lefthook file and the makefile's recipe lines.
+ */
+export function workflowCommands(host, targetRoot) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return [...stepCommands(host, root), ...recipeLines(host, root).flat()];
+}
+/**
+ * Every directory the target root's workflow steps and lefthook commands are set to run in, as
+ * written: each `working-directory` of a workflow file and each `root` of a lefthook file.
+ */
+export function commandDirectories(host, targetRoot) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return [
+        ...workflowFiles(host, root).flatMap((path) => runCommands(readText(host, path) ?? "", WORKING_DIRECTORY)),
+        ...LEFTHOOK_FILES.flatMap((name) => runCommands(readText(host, joinPath(root, name)) ?? "", LEFTHOOK_ROOT)),
+    ];
+}
+/** The workflow files in `.github/workflows` at one root, by path in name order. */
+function workflowFiles(host, root) {
+    return pathsIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name));
+}
+/** Every token the commands {@link workflowCommands} reads hold. */
+export function workflowTokens(host, targetRoot) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return [
+        ...stepCommands(host, root).flatMap((command) => scriptTokens(command)),
+        ...recipeTokens(host, root).map(({ token }) => token),
+    ];
+}
+/** The commands of the workflow steps, git hooks and hook managers at one root. */
+function stepCommands(host, root) {
+    const commands = [];
+    for (const path of workflowFiles(host, root)) {
+        commands.push(...runCommands(readText(host, path) ?? ""));
+    }
+    for (const dir of HOOK_DIRS) {
+        for (const path of pathsIn(host, joinPath(root, dir), () => true)) {
+            commands.push(...(readText(host, path) ?? "").split(/\r?\n/u).map(withoutComment));
+        }
+    }
+    for (const [name, key] of HOOK_MANAGERS) {
+        commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
+    }
+    return commands;
+}
+/**
+ * The own files the target root's workflow steps and git hooks name, as
+ * {@link workflowTokens} reads them: a token equal to a file's path below the target root,
+ * with or without a leading `./`, whatever directory the step runs in.
  */
 export function workflowEntries(host, targetRoot, files) {
     const found = [];
@@ -84,5 +169,15 @@ export function workflowEntries(host, targetRoot, files) {
             found.push({ file, source: token });
         }
     }
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    for (const { token, dir } of recipeTokens(host, root)) {
+        const below = COMPUTED.test(token) || dir === ""
+            ? undefined
+            : relativePath(root, resolvePath(joinPath(root, dir), token));
+        const file = below === undefined ? undefined : files.byPath.get(below);
+        if (file !== undefined) {
+            found.push({ file, source: token });
+        }
+    }
     return found;
 }

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.4",
+  "version": "8.0.0-dev.10",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.4",
+  "version": "8.0.0-dev.10",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -19,6 +19,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
+    "gen": "node scripts/gen-contract.ts",
     "prepack": "npm run build",
     "typecheck": "tsc -p tsconfig.json",
     "typecheck:tests": "tsc -p tsconfig.test.json",
@@ -30,7 +31,7 @@
     "lint:fix": "eslint . --fix && prettier --write ."
   },
   "dependencies": {
-    "@typescript/native": "npm:typescript@7.1.0-dev.20261010.1"
+    "@typescript/native": "npm:typescript@7.1.0-dev.20261014.1"
   },
   "overrides": {
     "qs": "^6.15.2"
@@ -43,9 +44,9 @@
     "@types/node": "24.19.2",
     "eslint": "10.12.0",
     "fast-check": "4.10.2",
-    "prettier": "3.9.9",
+    "prettier": "3.9.10",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.71.1",
+    "typescript-eslint": "8.71.2",
     "vitest": "5.0.4"
   },
   "publishConfig": {