@danieljvdm/dev-kit 0.17.0 → 1.0.0

package/src/tool-ignore-patterns.js

@@ -1,9 +0,0 @@
-/** Tool-owned paths excluded by Dev Kit's lint and format presets. */
-export const devKitToolIgnorePatterns = [
-  ".agents/**",
-  ".claude/**",
-  ".dev-kit/**",
-  ".opencode/**",
-  ".repos/**",
-  ".vite-hooks/_/**",
-];

package/src/vite-plus-dependency.ts

@@ -1,69 +0,0 @@
-import { Effect, FileSystem, Path, Schema } from "effect";
-import semver from "semver";
-
-import { readDirectDependencyNames } from "./project-package.ts";
-import { VITE_PLUS_SUPPORTED_RANGE } from "./tool-metadata.ts";
-
-const InstalledVitePlusPackageSchema = Schema.fromJsonString(
-  Schema.Struct({ version: Schema.String }),
-);
-
-export class VitePlusDependencyError extends Schema.TaggedError<VitePlusDependencyError>()(
-  "VitePlusDependencyError",
-  { message: Schema.String },
-) {}
-
-export type InstalledVitePlus = {
-  readonly version: string;
-  readonly vpBin: string;
-};
-
-export const validateInstalledVitePlus = Effect.fn("validateInstalledVitePlus")(function* (
-  projectDir: string,
-) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const dependencies = yield* readDirectDependencyNames(projectDir);
-
-  if (!dependencies.includes("vite-plus")) {
-    return yield* VitePlusDependencyError.make({
-      message: "vite-plus must be a direct project dependency",
-    });
-  }
-  const packagePath = path.join(projectDir, "node_modules", "vite-plus", "package.json");
-
-  if (!(yield* fs.exists(packagePath))) {
-    return yield* VitePlusDependencyError.make({
-      message:
-        "vite-plus must be installed before enabling this setup: node_modules/vite-plus/package.json is missing",
-    });
-  }
-  const installed = yield* fs.readFileString(packagePath).pipe(
-    Effect.flatMap(Schema.decodeUnknownEffect(InstalledVitePlusPackageSchema)),
-    Effect.mapError(() =>
-      VitePlusDependencyError.make({
-        message: "installed vite-plus package metadata has no valid version",
-      }),
-    ),
-  );
-
-  if (!semver.valid(installed.version)) {
-    return yield* VitePlusDependencyError.make({
-      message: `installed vite-plus package metadata has invalid version: ${installed.version}`,
-    });
-  }
-  if (!semver.satisfies(installed.version, VITE_PLUS_SUPPORTED_RANGE)) {
-    return yield* VitePlusDependencyError.make({
-      message: `installed vite-plus ${installed.version} is incompatible with @danieljvdm/dev-kit; supported range: ${VITE_PLUS_SUPPORTED_RANGE}`,
-    });
-  }
-  const vpBin = path.join(projectDir, "node_modules", ".bin", "vp");
-
-  if (!(yield* fs.exists(vpBin))) {
-    return yield* VitePlusDependencyError.make({
-      message: "vite-plus is installed but node_modules/.bin/vp is missing",
-    });
-  }
-
-  return { version: installed.version, vpBin } satisfies InstalledVitePlus;
-});

package/src/vite-plus-hooks.ts

@@ -1,175 +0,0 @@
-import { Config, Effect, FileSystem, Path, Schema, Stream } from "effect";
-import { ChildProcess } from "effect/unstable/process";
-
-import { validateInstalledVitePlus } from "./vite-plus-dependency.ts";
-
-export const VITE_PLUS_HOOKS_DIR = ".vite-hooks";
-export const VITE_PLUS_HOOKS_PATH = `${VITE_PLUS_HOOKS_DIR}/_`;
-
-export type VitePlusHooksPlan = {
-  readonly action: "configure" | "unchanged" | "skipped";
-  readonly hooksDir: string;
-  readonly hooksPath: string;
-  readonly projectDir: string;
-  readonly vpBin: string;
-};
-
-export class VitePlusHooksDependencyError extends Schema.TaggedError<VitePlusHooksDependencyError>()(
-  "VitePlusHooksDependencyError",
-  { message: Schema.String },
-) {}
-
-export class VitePlusHooksConflictError extends Schema.TaggedError<VitePlusHooksConflictError>()(
-  "VitePlusHooksConflictError",
-  { hooksPath: Schema.String },
-) {
-  override get message() {
-    return `core.hooksPath is already set to "${this.hooksPath}"; refusing to replace another Git hook manager`;
-  }
-}
-
-class VitePlusHooksCommandError extends Schema.TaggedError<VitePlusHooksCommandError>()(
-  "VitePlusHooksCommandError",
-  { command: Schema.String, exitCode: Schema.Int, output: Schema.String },
-) {
-  override get message() {
-    return this.output.length > 0
-      ? `${this.command} exited with code ${this.exitCode}: ${this.output}`
-      : `${this.command} exited with code ${this.exitCode}`;
-  }
-}
-
-class VitePlusHooksConvergenceError extends Schema.TaggedError<VitePlusHooksConvergenceError>()(
-  "VitePlusHooksConvergenceError",
-  { message: Schema.String },
-) {}
-
-const runCommand = Effect.fn("runVitePlusHooksCommand")(function* (
-  cwd: string,
-  command: string,
-  args: ReadonlyArray<string>,
-  allowedExitCodes: ReadonlyArray<number> = [0],
-) {
-  const child = yield* ChildProcess.make(command, args, {
-    cwd,
-    stderr: "pipe",
-    stdout: "pipe",
-  });
-  const [output, exitCode] = yield* Effect.all([
-    Stream.mkString(Stream.decodeText(child.all)),
-    child.exitCode,
-  ]);
-  const trimmed = output.trim();
-
-  if (!allowedExitCodes.includes(exitCode)) {
-    return yield* VitePlusHooksCommandError.make({
-      command: [command, ...args].join(" "),
-      exitCode,
-      output: trimmed,
-    });
-  }
-
-  return { exitCode, output: trimmed };
-});
-
-const hasExecutableFile = Effect.fn("hasExecutableVitePlusHookFile")(function* (filePath: string) {
-  const fs = yield* FileSystem.FileSystem;
-
-  if (!(yield* fs.exists(filePath))) return false;
-  const info = yield* fs.stat(filePath);
-
-  return info.type === "File" && (info.mode & 0o111) !== 0;
-});
-
-const hasVitePlusPreCommitHook = Effect.fn("hasVitePlusPreCommitHook")(function* (
-  filePath: string,
-) {
-  const fs = yield* FileSystem.FileSystem;
-
-  if (!(yield* fs.exists(filePath))) return false;
-  const info = yield* fs.stat(filePath);
-
-  return info.type === "File" && (yield* fs.readFileString(filePath)).includes("vp staged");
-});
-
-const inspectVitePlusHooks = Effect.fn("inspectVitePlusHooks")(function* (projectDir: string) {
-  const path = yield* Path.Path;
-  const configuredPath = yield* runCommand(
-    projectDir,
-    "git",
-    ["config", "--local", "--get", "core.hooksPath"],
-    [0, 1],
-  );
-  const hooksPath = configuredPath.exitCode === 0 ? configuredPath.output : "";
-
-  if (
-    hooksPath.length > 0 &&
-    hooksPath !== VITE_PLUS_HOOKS_PATH &&
-    hooksPath !== ".husky" &&
-    !hooksPath.startsWith(".husky/")
-  ) {
-    return yield* VitePlusHooksConflictError.make({ hooksPath });
-  }
-  const internalDir = path.join(projectDir, VITE_PLUS_HOOKS_DIR, "_");
-  const [hasLauncher, hasDispatcher, hasPreCommit, hasInternalIgnore] = yield* Effect.all([
-    hasExecutableFile(path.join(internalDir, "h")),
-    hasExecutableFile(path.join(internalDir, "pre-commit")),
-    hasVitePlusPreCommitHook(path.join(projectDir, VITE_PLUS_HOOKS_DIR, "pre-commit")),
-    FileSystem.FileSystem.pipe(
-      Effect.flatMap((fs) => fs.readFileString(path.join(internalDir, ".gitignore"))),
-      Effect.map((contents) => contents.split(/\r?\n/).includes("*")),
-      Effect.orElseSucceed(() => false),
-    ),
-  ]);
-
-  return (
-    hooksPath === VITE_PLUS_HOOKS_PATH &&
-    hasLauncher &&
-    hasDispatcher &&
-    hasPreCommit &&
-    hasInternalIgnore
-  );
-});
-
-export const planVitePlusHooks = Effect.fn("planVitePlusHooks")(function* (projectDir: string) {
-  const { vpBin } = yield* validateInstalledVitePlus(projectDir).pipe(
-    Effect.mapError((error) =>
-      VitePlusHooksDependencyError.make({
-        message: `${error.message} before enabling setup.vitePlus.hooks`,
-      }),
-    ),
-  );
-  const viteGitHooks = yield* Config.string("VITE_GIT_HOOKS").pipe(Config.withDefault(""));
-  const husky = yield* Config.string("HUSKY").pipe(Config.withDefault(""));
-  const action =
-    viteGitHooks === "0" || husky === "0"
-      ? "skipped"
-      : (yield* inspectVitePlusHooks(projectDir))
-        ? "unchanged"
-        : "configure";
-
-  return {
-    action,
-    hooksDir: VITE_PLUS_HOOKS_DIR,
-    hooksPath: VITE_PLUS_HOOKS_PATH,
-    projectDir,
-    vpBin,
-  } satisfies VitePlusHooksPlan;
-});
-
-export const applyVitePlusHooksPlan = Effect.fn("applyVitePlusHooksPlan")(function* (
-  plan: VitePlusHooksPlan,
-) {
-  if (plan.action !== "configure") return;
-  yield* runCommand(plan.projectDir, plan.vpBin, [
-    "config",
-    "--no-agent",
-    "--hooks-dir",
-    plan.hooksDir,
-  ]);
-  if (!(yield* inspectVitePlusHooks(plan.projectDir))) {
-    return yield* VitePlusHooksConvergenceError.make({
-      message: `Vite+ hook setup did not converge at ${plan.hooksPath}`,
-    });
-  }
-});

package/src/vite-plus-workflow.ts

@@ -1,82 +0,0 @@
-import { Effect, Schema } from "effect";
-
-import { readDirectDependencyNames } from "./project-package.ts";
-import { planScaffold, readScaffoldTemplate, replaceUniqueTemplateMarker } from "./scaffold.ts";
-import { validateInstalledVitePlus } from "./vite-plus-dependency.ts";
-
-export const VITE_PLUS_GITHUB_ACTIONS_PATH = ".github/workflows/check.yml";
-export const VITE_PLUS_GITHUB_ACTIONS_TEMPLATE = "templates/vite-plus/github-actions-check.yml";
-
-export class VitePlusWorkflowSupportError extends Schema.TaggedError<VitePlusWorkflowSupportError>()(
-  "VitePlusWorkflowSupportError",
-  { message: Schema.String },
-) {}
-
-const LOCKED_DEV_KIT_COMMAND =
-  "bun ./node_modules/@danieljvdm/dev-kit/bin/dev-kit.mjs apply --locked";
-
-export const renderVitePlusWorkflowTemplate = (
-  template: string,
-  options: { readonly devKitCommand?: string } = {},
-): string => {
-  const devKitCommand = options.devKitCommand;
-
-  return devKitCommand === undefined || devKitCommand === LOCKED_DEV_KIT_COMMAND
-    ? template
-    : replaceUniqueTemplateMarker(template, LOCKED_DEV_KIT_COMMAND, devKitCommand);
-};
-
-export const validateVitePlusWorkflowSupport = Effect.fn("validateVitePlusWorkflowSupport")(
-  function* (projectDir: string, packageRoot: string, typescriptPackage: string) {
-    const dependencies = yield* readDirectDependencyNames(projectDir);
-    const required = new Set(["effect", "@effect/tsgo", typescriptPackage]);
-
-    yield* validateInstalledVitePlus(projectDir).pipe(
-      Effect.mapError((error) => VitePlusWorkflowSupportError.make({ message: error.message })),
-    );
-
-    if (projectDir !== packageRoot) required.add("@danieljvdm/dev-kit");
-    const missing = [...required].filter((dependency) => !dependencies.includes(dependency));
-
-    if (missing.length > 0) {
-      return yield* VitePlusWorkflowSupportError.make({
-        message: `setup.vitePlus.workflow requires direct dependencies: ${missing.join(", ")}`,
-      });
-    }
-  },
-);
-
-export const planVitePlusWorkflow = (options: {
-  readonly packageRoot: string;
-  readonly projectDir: string;
-  readonly effectTsgoEnabled: boolean;
-  readonly typescriptPackage: string;
-}) =>
-  planScaffold({
-    projectDir: options.projectDir,
-    path: VITE_PLUS_GITHUB_ACTIONS_PATH,
-    content: Effect.gen(function* () {
-      if (!options.effectTsgoEnabled) {
-        return yield* VitePlusWorkflowSupportError.make({
-          message:
-            "setup.vitePlus.workflow requires setup.effectTsgo.enabled so the scaffolded workflow's typecheck uses the Effect-patched compiler",
-        });
-      }
-      yield* validateVitePlusWorkflowSupport(
-        options.projectDir,
-        options.packageRoot,
-        options.typescriptPackage,
-      );
-      const template = yield* readScaffoldTemplate(
-        options.packageRoot,
-        VITE_PLUS_GITHUB_ACTIONS_TEMPLATE,
-      );
-
-      return renderVitePlusWorkflowTemplate(
-        template,
-        options.projectDir === options.packageRoot
-          ? { devKitCommand: "./bin/dev-kit.mjs apply --locked" }
-          : {},
-      );
-    }),
-  });

package/src/vite-plus.js

@@ -1,88 +0,0 @@
-import { recommendedOxfmtConfig } from "./oxfmt.js";
-import { createAbsoluteImportsOxlintOverride, recommendedOxlintConfig } from "./oxlint.js";
-import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
-
-export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
-
-const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
-
-const validateWorkspacePackage = (packageDir) => {
-  const segments = packageDir.split(/[\\/]/);
-
-  if (
-    packageDir.trim().length === 0 ||
-    packageDir === "." ||
-    packageDir === "./" ||
-    packageDir === ".\\" ||
-    packageDir.startsWith("/") ||
-    packageDir.startsWith("\\") ||
-    /^[A-Za-z]:[\\/]/.test(packageDir) ||
-    segments.includes("..")
-  ) {
-    throw new Error(`workspace package must be a project-relative subdirectory: ${packageDir}`);
-  }
-};
-
-const createTypecheckTask = (options) => {
-  if (options?.strategy !== "workspace") {
-    const command = options?.command ?? "tsc --noEmit";
-
-    if (command.trim().length === 0) throw new Error("typecheck command must not be empty");
-
-    return command;
-  }
-  const concurrency = options.concurrency ?? 4;
-
-  if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 32) {
-    throw new Error("workspace typecheck concurrency must be between 1 and 32");
-  }
-  if (options.packages.length === 0) {
-    throw new Error("workspace typechecking requires at least one package directory");
-  }
-  const packages = [...new Set(options.packages)];
-
-  if (packages.length !== options.packages.length) {
-    throw new Error("workspace typecheck packages must be unique");
-  }
-  for (const packageDir of packages) validateWorkspacePackage(packageDir);
-  const filters = packages
-    .map((packageDir) => `--filter ${shellQuote(`./${packageDir}`)}`)
-    .join(" ");
-
-  return {
-    command: `vp run --cache --concurrency-limit ${concurrency} ${filters} --fail-if-no-match typecheck`,
-    cache: false,
-  };
-};
-
-/** Build composable quality defaults for a project-owned Vite+ config. */
-export const createRecommendedVitePlusConfig = (options = {}) => {
-  const ignorePatterns = [...devKitToolIgnorePatterns, ...(options.ignorePatterns ?? [])];
-  const lintOverrides = options.absoluteImports
-    ? [
-        ...recommendedOxlintConfig.overrides,
-        createAbsoluteImportsOxlintOverride(options.absoluteImports),
-      ]
-    : recommendedOxlintConfig.overrides;
-
-  return {
-    staged: {
-      "*": "vp check --fix",
-    },
-    fmt: {
-      ...recommendedOxfmtConfig,
-      ignorePatterns,
-    },
-    lint: {
-      ...recommendedOxlintConfig,
-      ignorePatterns,
-      overrides: lintOverrides,
-    },
-    run: {
-      tasks: {
-        check: ["vp fmt --check", "vp lint", "vp test", "vp run typecheck"],
-        typecheck: createTypecheckTask(options.typecheck),
-      },
-    },
-  };
-};

package/src/worktrunk-config.ts

@@ -1,88 +0,0 @@
-import { Effect, Schema } from "effect";
-
-import {
-  detectPackageManager,
-  PACKAGE_MANAGER_COMMANDS,
-  readDirectDependencyNames,
-  readProjectPackage,
-} from "./project-package.ts";
-import { planScaffold, readScaffoldTemplate, replaceUniqueTemplateMarker } from "./scaffold.ts";
-
-export const WORKTRUNK_CONFIG_PATH = ".config/wt.toml";
-export const WORKTRUNK_CONFIG_TEMPLATE = "templates/worktrunk/wt.toml";
-
-export class WorktrunkConfigSupportError extends Schema.TaggedError<WorktrunkConfigSupportError>()(
-  "WorktrunkConfigSupportError",
-  { message: Schema.String },
-) {}
-
-export type WorktrunkConfigCommands = {
-  readonly preMerge: string;
-  readonly install: string;
-  readonly dev: string;
-};
-
-const TEMPLATE_COMMANDS: WorktrunkConfigCommands = {
-  preMerge: "vp run check",
-  install: "vp install",
-  dev: "vp dev",
-};
-
-export const renderWorktrunkConfigTemplate = (
-  template: string,
-  commands: WorktrunkConfigCommands = TEMPLATE_COMMANDS,
-): string => {
-  const replacements: ReadonlyArray<readonly [string, string]> = [
-    [`pre-merge = "${TEMPLATE_COMMANDS.preMerge}"`, `pre-merge = "${commands.preMerge}"`],
-    [`install = "${TEMPLATE_COMMANDS.install}"`, `install = "${commands.install}"`],
-    [TEMPLATE_COMMANDS.dev, commands.dev],
-  ];
-  let rendered = template;
-
-  for (const [marker, replacement] of replacements) {
-    if (marker === replacement) continue;
-    rendered = replaceUniqueTemplateMarker(rendered, marker, replacement);
-  }
-
-  return rendered;
-};
-
-export const resolveWorktrunkConfigCommands = Effect.fn("resolveWorktrunkConfigCommands")(
-  function* (projectDir: string) {
-    const dependencies = yield* readDirectDependencyNames(projectDir);
-
-    if (dependencies.includes("vite-plus")) return TEMPLATE_COMMANDS;
-    const projectPackage = yield* readProjectPackage(projectDir).pipe(
-      Effect.catchTag("ProjectPackageError", (error) =>
-        error.message.startsWith("package.json not found:") ? Effect.void : Effect.fail(error),
-      ),
-    );
-    const scripts = projectPackage?.scripts ?? {};
-
-    if (scripts["check"] === undefined) {
-      return yield* WorktrunkConfigSupportError.make({
-        message:
-          'setup.worktrunk.config requires a direct vite-plus dependency or a root "check" package script for the pre-merge hook',
-      });
-    }
-    const manager = yield* detectPackageManager(projectDir, projectPackage?.packageManager);
-
-    return {
-      preMerge: "bun run check",
-      install: PACKAGE_MANAGER_COMMANDS[manager ?? "bun"].install,
-      dev: "bun run dev",
-    } satisfies WorktrunkConfigCommands;
-  },
-);
-
-export const planWorktrunkConfig = (packageRoot: string, projectDir: string) =>
-  planScaffold({
-    projectDir,
-    path: WORKTRUNK_CONFIG_PATH,
-    content: Effect.gen(function* () {
-      const template = yield* readScaffoldTemplate(packageRoot, WORKTRUNK_CONFIG_TEMPLATE);
-      const commands = yield* resolveWorktrunkConfigCommands(projectDir);
-
-      return renderWorktrunkConfigTemplate(template, commands);
-    }),
-  });

package/templates/AGENTS.md

@@ -1,11 +0,0 @@
-<!-- DEV KIT START -->
-
-# Dev Kit
-
-This project uses `@danieljvdm/dev-kit` to manage portable agent skills and reproducible setup from `dev-kit.jsonc` and `dev-kit.lock.json`.
-
-For dev-kit operations, use the `dev-kit` skill and read `{{DEV_KIT_SKILL_PATH}}` before changing managed outputs.
-
-{{EFFECT_INSTRUCTIONS}}{{PROJECT_COMMAND_POLICY}}
-
-<!-- DEV KIT END -->

package/templates/vite-plus/github-actions-check.yml

@@ -1,51 +0,0 @@
-name: Check
-
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v7
-        with:
-          persist-credentials: false
-
-      # setup-bun resolves the consumer's packageManager or engines.bun version.
-      - name: Set up Bun
-        uses: oven-sh/setup-bun@v2
-
-      - name: Set up Vite+ and install dependencies
-        uses: voidzero-dev/setup-vp@v1.16.1
-        with:
-          # Vite+ version intentionally resolves from the consumer manifest/lock.
-          node-version: "24"
-          cache: true
-          run-install: |
-            args: ["--frozen-lockfile", "--ignore-scripts"]
-
-      - name: Verify locked Dev Kit setup
-        run: bun ./node_modules/@danieljvdm/dev-kit/bin/dev-kit.mjs apply --locked
-
-      - name: Check formatting
-        run: vp fmt --check
-
-      - name: Lint
-        run: vp lint
-
-      - name: Run tests
-        run: vp test
-
-      - name: Type check with Effect TypeScript-Go
-        run: vp run typecheck

package/templates/worktrunk/wt.toml

@@ -1,27 +0,0 @@
-# Worktrunk project hooks, scaffolded by @danieljvdm/dev-kit (setup.worktrunk.config).
-# This repository owns the file — edit hooks freely; dev-kit never rewrites it.
-# Hooks never run until each user reviews and approves them: wt config approvals add
-# Reference: https://worktrunk.dev/hooks/
-
-# Full validation before a worktree merges back.
-pre-merge = "vp run check"
-
-# Copy gitignored files matched by .worktreeinclude (.env, local caches) from
-# the source worktree; without a .worktreeinclude file this is a no-op.
-[[pre-start]]
-copy-ignored = "wt step copy-ignored --require-include"
-
-# Install dependencies after ignored files land so the new worktree is runnable.
-[[pre-start]]
-install = "vp install"
-
-# Optional per-worktree dev server on a stable branch-derived port; tether stops
-# the server when its worktree is removed. Point the command at this
-# repository's dev entrypoint (for example add `apps/web` in a monorepo) and
-# uncomment:
-# [post-start]
-# dev = "wt step tether -- vp dev --host 127.0.0.1 --port {{ branch | hash_port }} --strictPort"
-
-# Optional: show each worktree's dev-server URL in `wt list`:
-# [list]
-# url = "http://localhost:{{ branch | hash_port }}"