@danieljvdm/dev-kit 0.18.0 → 1.0.1

package/src/legacy-project.ts

@@ -0,0 +1,67 @@
+import { Schema } from "effect";
+
+import { DigestSchema } from "./path-digest.ts";
+
+const EnabledSetupSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+});
+
+export const LegacyDevKitManifestSchema = Schema.Struct({
+  setup: Schema.optional(
+    Schema.Struct({
+      effectSource: Schema.optional(EnabledSetupSchema),
+      effectTsgo: Schema.optional(EnabledSetupSchema),
+      vitePlus: Schema.optional(
+        Schema.Struct({
+          hooks: Schema.optional(EnabledSetupSchema),
+        }),
+      ),
+    }),
+  ),
+});
+
+export type LegacyDevKitManifest = typeof LegacyDevKitManifestSchema.Type;
+
+export const legacySetupFlags = (manifest: LegacyDevKitManifest) => ({
+  effectSource: manifest.setup?.effectSource?.enabled ?? false,
+  effectTsgo: manifest.setup?.effectTsgo?.enabled ?? false,
+  vitePlusHooks: manifest.setup?.vitePlus?.hooks?.enabled ?? false,
+});
+
+const LegacyCatalogProvenanceSchema = 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 const LegacyManagedSkillOutputSchema = 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(LegacyCatalogProvenanceSchema),
+});
+
+export type LegacyManagedSkillOutput = typeof LegacyManagedSkillOutputSchema.Type;
+
+const LegacyOtherOutputSchema = Schema.Struct({
+  resourceId: Schema.String,
+  path: Schema.String,
+});
+
+export const LegacyDevKitLockSchema = Schema.Struct({
+  version: Schema.Literal(1),
+  toolVersion: Schema.String,
+  outputs: Schema.Array(Schema.Union([LegacyManagedSkillOutputSchema, LegacyOtherOutputSchema])),
+});

package/src/oxfmt.ts

@@ -5,10 +5,7 @@ import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
 export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
 
 /**
- * Canonical formatting defaults for standalone Oxfmt and Vite+ projects.
- *
- * Oxfmt does not support config inheritance. Spread this object into a
- * standalone Oxfmt config or Vite+'s `fmt` block before local overrides.
+ * Formatting defaults for this repository's Vite+ config.
  */
 export const recommendedOxfmtConfig = {
   arrowParens: "always",

package/src/oxlint.ts

@@ -12,8 +12,7 @@ export type AbsoluteImportsOptions = {
 /**
  * Build an Oxlint override that forbids `../` imports inside the given globs,
  * so those files import through tsconfig path aliases such as `@/*`. Append it
- * to a standalone Oxlint config's `overrides`, or opt in through
- * `createRecommendedVitePlusConfig({ absoluteImports })`.
+ * to this repository's Oxlint overrides.
  */
 export const createAbsoluteImportsOxlintOverride = (options: AbsoluteImportsOptions) => {
   if (options.files.length === 0) {
@@ -39,11 +38,7 @@ export const createAbsoluteImportsOxlintOverride = (options: AbsoluteImportsOpti
 };
 
 /**
- * High-signal Oxlint defaults for TypeScript projects.
- *
- * Extend this object from standalone Oxlint's `extends`, or from Vite+'s
- * `lint.extends`, so project-local plugins, rules, and overrides compose
- * without losing nested configuration.
+ * High-signal Oxlint defaults for this repository.
  */
 export const recommendedOxlintConfig = {
   ignorePatterns: [...devKitToolIgnorePatterns],
@@ -53,15 +48,15 @@ export const recommendedOxlintConfig = {
   jsPlugins: [
     {
       name: "anti-slop",
-      specifier: "@danieljvdm/dev-kit/oxlint-plugin-anti-slop",
+      specifier: "./src/oxlint-plugin-anti-slop/runtime.js",
     },
     {
       name: "effect",
-      specifier: "@danieljvdm/dev-kit/oxlint-plugin-effect",
+      specifier: "./src/oxlint-plugin-effect.js",
     },
     {
       name: "stylistic",
-      specifier: "@danieljvdm/dev-kit/oxlint-plugin-style",
+      specifier: "./src/oxlint-plugin-style.js",
     },
   ],
   plugins: ["import", "react", "vitest"],

package/src/path-digest.ts

@@ -153,6 +153,66 @@ export const observePath = Effect.fn("observeManagedPath")(function* (absolutePa
   );
 });
 
+export const observeDirectoryWithoutEntry = Effect.fn("observeDirectoryWithoutEntry")(function* (
+  absolutePath: string,
+  excludedEntry: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+
+  if (
+    excludedEntry.length === 0 ||
+    excludedEntry === "." ||
+    excludedEntry === ".." ||
+    excludedEntry.includes("/") ||
+    excludedEntry.includes("\\")
+  ) {
+    return yield* PathInspectionError.make({
+      path: absolutePath,
+      operation: "exclude a direct directory entry",
+      cause: excludedEntry,
+    });
+  }
+  const observed = yield* observeSymbolicLink(absolutePath);
+
+  if (observed.kind === "missing") return { kind: "missing" } as const;
+  if (observed.kind === "symlink") {
+    return yield* PathInspectionError.make({
+      path: absolutePath,
+      operation: "inspect a regular directory",
+      cause: "path is a symlink",
+    });
+  }
+  const info = yield* fs.stat(absolutePath);
+
+  if (info.type !== "Directory") {
+    return yield* PathInspectionError.make({
+      path: absolutePath,
+      operation: "inspect a regular directory",
+      cause: info.type,
+    });
+  }
+  const entries = (yield* fs.readDirectory(absolutePath))
+    .filter((entry) => entry !== excludedEntry)
+    .sort(compareUtf8);
+  const frames: Array<string | Uint8Array> = ["directory-v1"];
+
+  for (const entry of entries) {
+    const child = yield* digestFileSystemPath(path.join(absolutePath, entry), canonicalFileMode);
+
+    if (child.kind === "missing") {
+      return yield* PathInspectionError.make({
+        path: path.join(absolutePath, entry),
+        operation: "inspect a stable directory tree",
+        cause: "path disappeared during inspection",
+      });
+    }
+    frames.push(entry, child.kind, child.digest);
+  }
+
+  return { kind: "directory", digest: yield* digestFrames(frames) } as const;
+});
+
 export const digestText = Effect.fn("digestText")(function* (value: string) {
   return yield* digestFrames(["text-v1", value]);
 });