@danieljvdm/dev-kit 0.17.0 → 1.0.0

package/src/manifest.ts

@@ -1,216 +0,0 @@
-import { Schema } from "effect";
-
-import { SKILL_SELECTOR_PATTERN } from "./skill-selector.ts";
-import { TYPESCRIPT_PACKAGE_NAME_PATTERN } from "./typescript-package-name.ts";
-
-export type HarnessTarget = "agents" | "claude" | "opencode";
-
-export const SyncMode = Schema.Literals(["copy", "symlink"]);
-export type SyncMode = "copy" | "symlink";
-
-export const TargetConfigSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-  mode: Schema.optional(SyncMode),
-  path: Schema.optional(Schema.String),
-});
-
-export type TargetConfig = typeof TargetConfigSchema.Type;
-
-export const EffectTsgoSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-  force: Schema.optional(Schema.Boolean),
-  typescriptPackage: Schema.optional(
-    Schema.String.check(Schema.isPattern(TYPESCRIPT_PACKAGE_NAME_PATTERN)),
-  ),
-});
-
-export type EffectTsgoSetup = typeof EffectTsgoSetupSchema.Type;
-
-export const EffectSourceSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-  packageName: Schema.optional(
-    Schema.String.check(Schema.isPattern(TYPESCRIPT_PACKAGE_NAME_PATTERN)),
-  ),
-  path: Schema.optional(Schema.String),
-  repository: Schema.optional(Schema.String),
-});
-
-export type EffectSourceSetup = typeof EffectSourceSetupSchema.Type;
-
-export const AgentInstructionsSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-});
-
-export type AgentInstructionsSetup = typeof AgentInstructionsSetupSchema.Type;
-
-export const ClaudeInstructionsSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-});
-
-export type ClaudeInstructionsSetup = typeof ClaudeInstructionsSetupSchema.Type;
-
-export const VitePlusHooksSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-});
-
-export const VitePlusWorkflowSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-});
-export type VitePlusWorkflowSetup = typeof VitePlusWorkflowSetupSchema.Type;
-
-export const VitePlusSetupSchema = Schema.Struct({
-  hooks: Schema.optional(VitePlusHooksSetupSchema),
-  workflow: Schema.optional(VitePlusWorkflowSetupSchema),
-});
-
-export type VitePlusSetup = typeof VitePlusSetupSchema.Type;
-
-export const WorktrunkConfigSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-});
-export type WorktrunkConfigSetup = typeof WorktrunkConfigSetupSchema.Type;
-
-export const WorktrunkSetupSchema = Schema.Struct({
-  config: Schema.optional(WorktrunkConfigSetupSchema),
-});
-export type WorktrunkSetup = typeof WorktrunkSetupSchema.Type;
-
-export const DevKitManifestSchema = Schema.Struct({
-  $schema: Schema.optional(Schema.String),
-  include: Schema.Array(Schema.String.check(Schema.isPattern(SKILL_SELECTOR_PATTERN))),
-  exclude: Schema.optional(
-    Schema.Array(Schema.String.check(Schema.isPattern(SKILL_SELECTOR_PATTERN))),
-  ),
-  setup: Schema.optional(
-    Schema.Struct({
-      agentInstructions: Schema.optional(AgentInstructionsSetupSchema),
-      claudeInstructions: Schema.optional(ClaudeInstructionsSetupSchema),
-      effectSource: Schema.optional(EffectSourceSetupSchema),
-      effectTsgo: Schema.optional(EffectTsgoSetupSchema),
-      vitePlus: Schema.optional(VitePlusSetupSchema),
-      worktrunk: Schema.optional(WorktrunkSetupSchema),
-    }),
-  ),
-  targets: Schema.optional(
-    Schema.Struct({
-      agents: Schema.optional(TargetConfigSchema),
-      claude: Schema.optional(TargetConfigSchema),
-      opencode: Schema.optional(TargetConfigSchema),
-    }),
-  ),
-});
-
-export type DevKitManifest = typeof DevKitManifestSchema.Type;
-
-export type NormalizedTargetConfig = {
-  readonly enabled: boolean;
-  readonly mode: SyncMode;
-  readonly path: string;
-};
-
-export type NormalizedManifest = {
-  readonly include: ReadonlyArray<string>;
-  readonly exclude: ReadonlyArray<string>;
-  readonly setup: {
-    readonly agentInstructions: {
-      readonly enabled: boolean;
-    };
-    readonly claudeInstructions: {
-      readonly enabled: boolean;
-    };
-    readonly effectSource: {
-      readonly enabled: boolean;
-      readonly packageName: string;
-      readonly path: string;
-      readonly repository: string;
-    };
-    readonly effectTsgo: {
-      readonly enabled: boolean;
-      readonly force: boolean;
-      readonly typescriptPackage: string;
-    };
-    readonly vitePlus: {
-      readonly hooks: {
-        readonly enabled: boolean;
-      };
-      readonly workflow: {
-        readonly enabled: boolean;
-      };
-    };
-    readonly worktrunk: {
-      readonly config: {
-        readonly enabled: boolean;
-      };
-    };
-  };
-  readonly targets: Readonly<Record<HarnessTarget, NormalizedTargetConfig>>;
-};
-
-const DEFAULT_TARGET_PATHS: Readonly<Record<HarnessTarget, string>> = {
-  agents: ".agents/skills",
-  claude: ".claude/skills",
-  opencode: ".opencode/skills",
-};
-
-const DEFAULT_TARGETS: Readonly<Record<HarnessTarget, NormalizedTargetConfig>> = {
-  agents: { enabled: true, mode: "copy", path: DEFAULT_TARGET_PATHS.agents },
-  claude: { enabled: false, mode: "symlink", path: DEFAULT_TARGET_PATHS.claude },
-  opencode: { enabled: false, mode: "symlink", path: DEFAULT_TARGET_PATHS.opencode },
-};
-
-export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest => {
-  const targets = {
-    ...DEFAULT_TARGETS,
-  };
-
-  for (const key of ["agents", "claude", "opencode"] as const) {
-    const override = manifest.targets?.[key];
-
-    if (override) {
-      targets[key] = {
-        enabled: override.enabled ?? DEFAULT_TARGETS[key].enabled,
-        mode: override.mode ?? DEFAULT_TARGETS[key].mode,
-        path: override.path ?? DEFAULT_TARGETS[key].path,
-      };
-    }
-  }
-
-  return {
-    exclude: manifest.exclude ?? [],
-    include: manifest.include,
-    setup: {
-      agentInstructions: {
-        enabled: manifest.setup?.agentInstructions?.enabled ?? false,
-      },
-      claudeInstructions: {
-        enabled: manifest.setup?.claudeInstructions?.enabled ?? false,
-      },
-      effectSource: {
-        enabled: manifest.setup?.effectSource?.enabled ?? false,
-        packageName: manifest.setup?.effectSource?.packageName ?? "effect",
-        path: manifest.setup?.effectSource?.path ?? ".repos/effect",
-        repository:
-          manifest.setup?.effectSource?.repository ?? "https://github.com/Effect-TS/effect.git",
-      },
-      effectTsgo: {
-        enabled: manifest.setup?.effectTsgo?.enabled ?? false,
-        force: manifest.setup?.effectTsgo?.force ?? false,
-        typescriptPackage: manifest.setup?.effectTsgo?.typescriptPackage ?? "typescript",
-      },
-      vitePlus: {
-        hooks: {
-          enabled: manifest.setup?.vitePlus?.hooks?.enabled ?? false,
-        },
-        workflow: {
-          enabled: manifest.setup?.vitePlus?.workflow?.enabled ?? false,
-        },
-      },
-      worktrunk: {
-        config: {
-          enabled: manifest.setup?.worktrunk?.config?.enabled ?? false,
-        },
-      },
-    },
-    targets,
-  };
-};

package/src/oxfmt.js

@@ -1,23 +0,0 @@
-/**
- * Runtime form of the typed preset declared in oxfmt.ts.
- *
- * This file is intentionally plain JavaScript because Node does not strip
- * TypeScript from packages in node_modules when tools load their config.
- */
-import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
-
-export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
-
-export const recommendedOxfmtConfig = {
-  arrowParens: "always",
-  endOfLine: "lf",
-  ignorePatterns: [...devKitToolIgnorePatterns],
-  printWidth: 100,
-  semi: true,
-  singleQuote: false,
-  sortImports: true,
-  sortPackageJson: true,
-  tabWidth: 2,
-  trailingComma: "all",
-  useTabs: false,
-};

package/src/oxlint-plugin-effect.d.ts

@@ -1,17 +0,0 @@
-interface EffectOxlintRule {
-  readonly meta: {
-    readonly type: "problem";
-    readonly docs: { readonly description: string };
-    readonly messages: Readonly<Record<string, string>>;
-  };
-  readonly create: (context: {
-    report(descriptor: { node: unknown; messageId: string }): void;
-  }) => Readonly<Record<string, (node: unknown) => void>>;
-}
-
-declare const effectOxlintPlugin: {
-  readonly meta: { readonly name: "dev-kit-effect" };
-  readonly rules: Readonly<Record<string, EffectOxlintRule>>;
-};
-
-export default effectOxlintPlugin;

package/src/oxlint-plugin-style.d.ts

@@ -1,8 +0,0 @@
-declare const styleOxlintPlugin: {
-  readonly meta: { readonly name: "dev-kit-style" };
-  readonly rules: {
-    readonly "padding-line-between-statements": unknown;
-  };
-};
-
-export default styleOxlintPlugin;

package/src/oxlint.js

@@ -1,94 +0,0 @@
-/**
- * Runtime form of the typed preset declared in oxlint.ts.
- *
- * This file is intentionally plain JavaScript because Node does not strip
- * TypeScript from packages in node_modules when Vite+ loads vite.config.ts.
- */
-import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
-
-export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
-
-export const createAbsoluteImportsOxlintOverride = (options) => {
-  if (options.files.length === 0) {
-    throw new Error("absolute imports enforcement requires at least one file glob");
-  }
-  const files = [...new Set(options.files)];
-
-  if (files.length !== options.files.length) {
-    throw new Error("absolute imports file globs must be unique");
-  }
-  for (const glob of files) {
-    if (glob.trim().length === 0) {
-      throw new Error("absolute imports file globs must not be blank");
-    }
-  }
-
-  return {
-    files,
-    rules: {
-      "import/no-relative-parent-imports": "error",
-    },
-  };
-};
-
-export const recommendedOxlintConfig = {
-  ignorePatterns: [...devKitToolIgnorePatterns],
-  options: {
-    typeAware: true,
-  },
-  jsPlugins: [
-    {
-      name: "effect",
-      specifier: "@danieljvdm/dev-kit/oxlint-plugin-effect",
-    },
-    {
-      name: "stylistic",
-      specifier: "@danieljvdm/dev-kit/oxlint-plugin-style",
-    },
-  ],
-  plugins: ["import", "react", "vitest"],
-  rules: {
-    eqeqeq: "error",
-    "import/default": "off",
-    "import/namespace": "off",
-    "import/no-cycle": "error",
-    "import/no-duplicates": ["error", { preferInline: true }],
-    "import/no-self-import": "error",
-    "react/exhaustive-deps": "error",
-    "react/rules-of-hooks": "error",
-    "stylistic/padding-line-between-statements": [
-      "error",
-      { blankLine: "always", prev: ["const", "let", "var"], next: "*" },
-      {
-        blankLine: "any",
-        prev: ["const", "let", "var"],
-        next: ["const", "let", "var"],
-      },
-      { blankLine: "always", prev: "*", next: "return" },
-    ],
-    "typescript/consistent-type-imports": [
-      "error",
-      { fixStyle: "inline-type-imports", prefer: "type-imports" },
-    ],
-    "typescript/no-floating-promises": "off",
-    "typescript/no-explicit-any": "error",
-    "typescript/no-misused-spread": "off",
-    "typescript/no-non-null-assertion": "error",
-    "typescript/require-array-sort-compare": "off",
-    "typescript/restrict-template-expressions": "off",
-    "typescript/switch-exhaustiveness-check": "error",
-    "unicorn/prefer-node-protocol": "error",
-    "vitest/no-focused-tests": "error",
-    "vitest/no-identical-title": "error",
-    "vitest/no-standalone-expect": "off",
-    "vitest/valid-expect": "error",
-  },
-  overrides: [
-    {
-      files: ["**/*.test.{ts,tsx}", "**/*.spec.{ts,tsx}"],
-      rules: {
-        "typescript/no-non-null-assertion": "off",
-      },
-    },
-  ],
-};

package/src/project-state.ts

@@ -1,122 +0,0 @@
-import { Schema } from "effect";
-
-import { DigestSchema } from "./path-digest.ts";
-
-export const CatalogProvenanceSchema = Schema.Union([
-  Schema.Struct({
-    source: Schema.String,
-    repository: Schema.String,
-    resolved: Schema.String,
-  }),
-  Schema.Struct({
-    package: Schema.String,
-    version: Schema.String,
-    skill: Schema.String,
-    digest: DigestSchema,
-  }),
-]);
-export type CatalogProvenance = typeof CatalogProvenanceSchema.Type;
-
-export const ManagedSkillOutputSchema = Schema.Struct({
-  resourceId: Schema.String,
-  path: Schema.String,
-  skill: Schema.String,
-  target: Schema.Literals(["agents", "claude", "opencode"]),
-  mode: Schema.Literals(["copy", "symlink"]),
-  kind: Schema.Literals(["directory", "symlink"]),
-  digest: DigestSchema,
-  catalog: Schema.optional(CatalogProvenanceSchema),
-});
-export type ManagedSkillOutput = typeof ManagedSkillOutputSchema.Type;
-
-export const ManagedAgentInstructionsOutputSchema = Schema.Struct({
-  resourceId: Schema.Literal("setup:agent-instructions"),
-  path: Schema.String,
-  sourcePath: Schema.String,
-  mode: Schema.Literal("copy"),
-  kind: Schema.Literal("file"),
-  digest: DigestSchema,
-});
-export type ManagedAgentInstructionsOutput = typeof ManagedAgentInstructionsOutputSchema.Type;
-
-export const ManagedClaudeInstructionsOutputSchema = Schema.Struct({
-  resourceId: Schema.Literal("setup:claude-instructions"),
-  path: Schema.String,
-  sourcePath: Schema.String,
-  mode: Schema.Literal("symlink"),
-  kind: Schema.Literal("symlink"),
-  digest: DigestSchema,
-});
-export type ManagedClaudeInstructionsOutput = typeof ManagedClaudeInstructionsOutputSchema.Type;
-
-// Legacy (dev-kit ≤0.14) lock entry for the previously managed check workflow.
-// Kept only so old locks and receipts still decode; planning discards these
-// entries, releasing the file to the repository. Never produced anymore.
-export const ManagedGeneratedFileOutputSchema = Schema.Struct({
-  resourceId: Schema.Literal("setup:vite-plus-github-actions"),
-  path: Schema.String,
-  sourcePath: Schema.String,
-  mode: Schema.Literal("copy"),
-  kind: Schema.Literal("file"),
-  digest: DigestSchema,
-});
-export type ManagedGeneratedFileOutput = typeof ManagedGeneratedFileOutputSchema.Type;
-
-export const ManagedInstructionOutputSchema = Schema.Union([
-  ManagedAgentInstructionsOutputSchema,
-  ManagedClaudeInstructionsOutputSchema,
-]);
-export type ManagedInstructionOutput = typeof ManagedInstructionOutputSchema.Type;
-
-export const ManagedOutputSchema = Schema.Union([
-  ManagedSkillOutputSchema,
-  ManagedInstructionOutputSchema,
-  ManagedGeneratedFileOutputSchema,
-]);
-export type ManagedOutput = typeof ManagedOutputSchema.Type;
-
-export const EffectTsgoLockSchema = Schema.Struct({
-  effectTsgoVersion: Schema.String,
-  typescriptPackage: Schema.String,
-  typescriptVersion: Schema.String,
-});
-export type EffectTsgoLock = typeof EffectTsgoLockSchema.Type;
-
-export const EffectSourceLockSchema = Schema.Struct({
-  packageName: Schema.String,
-  packageVersion: Schema.String,
-  path: Schema.String,
-  repository: Schema.String,
-  tag: Schema.String,
-});
-export type EffectSourceLock = typeof EffectSourceLockSchema.Type;
-
-export const DevKitLockSchema = Schema.Struct({
-  version: Schema.Literal(1),
-  toolVersion: Schema.String,
-  manifestDigest: DigestSchema,
-  setup: Schema.optional(
-    Schema.Struct({
-      effectSource: Schema.optional(EffectSourceLockSchema),
-      effectTsgo: Schema.optional(EffectTsgoLockSchema),
-    }),
-  ),
-  outputs: Schema.Array(ManagedOutputSchema),
-});
-export type DevKitLock = typeof DevKitLockSchema.Type;
-
-export const OwnershipReceiptSchema = Schema.Struct({
-  resourceId: Schema.String,
-  path: Schema.String,
-  mode: Schema.Literals(["copy", "symlink"]),
-  kind: Schema.Literals(["file", "directory", "symlink"]),
-  digest: DigestSchema,
-});
-export type OwnershipReceipt = typeof OwnershipReceiptSchema.Type;
-
-export const AppliedStateSchema = Schema.Struct({
-  version: Schema.Literal(1),
-  appliedLockDigest: DigestSchema,
-  outputs: Schema.Array(OwnershipReceiptSchema),
-});
-export type AppliedState = typeof AppliedStateSchema.Type;

package/src/scaffold.ts

@@ -1,79 +0,0 @@
-import { Effect, FileSystem, Path, Schema } from "effect";
-
-import { observeSymbolicLink } from "./node-symbolic-link.ts";
-
-export class ScaffoldTemplateError extends Schema.TaggedError<ScaffoldTemplateError>()(
-  "ScaffoldTemplateError",
-  { message: Schema.String },
-) {}
-
-export type ScaffoldPlan = {
-  readonly action: "scaffold" | "unchanged";
-  readonly path: string;
-  readonly destination: string;
-  readonly content?: string;
-};
-
-export const replaceUniqueTemplateMarker = (
-  template: string,
-  marker: string,
-  replacement: string,
-): string => {
-  const parts = template.split(marker);
-
-  if (parts.length !== 2) {
-    throw new Error(`expected exactly one generated template marker: ${marker}`);
-  }
-
-  return `${parts[0]}${replacement}${parts[1]}`;
-};
-
-export const readScaffoldTemplate = Effect.fn("readScaffoldTemplate")(function* (
-  packageRoot: string,
-  templatePath: string,
-) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const absolute = path.join(packageRoot, templatePath);
-
-  if (!(yield* fs.exists(absolute))) {
-    return yield* ScaffoldTemplateError.make({
-      message: `dev-kit scaffold template is missing: ${templatePath}`,
-    });
-  }
-
-  return yield* fs.readFileString(absolute);
-});
-
-// Scaffolds are created once and repository-owned afterwards: an existing
-// destination is never read, compared, updated, or removed, and `content` is
-// only computed (and validated) when the file is actually being created.
-export const planScaffold = Effect.fn("planScaffold")(function* <E, R>(options: {
-  readonly projectDir: string;
-  readonly path: string;
-  readonly content: Effect.Effect<string, E, R>;
-}) {
-  const path = yield* Path.Path;
-  const destination = path.join(options.projectDir, ...options.path.split("/"));
-  const observed = yield* observeSymbolicLink(destination);
-
-  if (observed.kind !== "missing") {
-    return { action: "unchanged", path: options.path, destination } satisfies ScaffoldPlan;
-  }
-
-  return {
-    action: "scaffold",
-    path: options.path,
-    destination,
-    content: yield* options.content,
-  } satisfies ScaffoldPlan;
-});
-
-export const applyScaffoldPlan = Effect.fn("applyScaffoldPlan")(function* (plan: ScaffoldPlan) {
-  if (plan.action !== "scaffold" || plan.content === undefined) return;
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-
-  yield* fs.makeDirectory(path.dirname(plan.destination), { recursive: true });
-  yield* fs.writeFileString(plan.destination, plan.content);
-});