@danieljvdm/dev-kit 0.5.0 → 0.7.0

package/src/path-digest.ts

@@ -2,9 +2,7 @@ import { Crypto, Effect, Encoding, FileSystem, Path, type PlatformError, Schema
 
 import { observeSymbolicLink } from "./node-symbolic-link.ts";
 
-export const DigestSchema = Schema.String.check(
-  Schema.isPattern(/^sha256:[0-9a-f]{64}$/),
-);
+export const DigestSchema = Schema.String.check(Schema.isPattern(/^sha256:[0-9a-f]{64}$/));
 export type Digest = typeof DigestSchema.Type;
 
 export type ObservedPath =
@@ -26,21 +24,29 @@ export class PathInspectionError extends Schema.TaggedErrorClass<PathInspectionE
 
 const textEncoder = new TextEncoder();
 
+// Git preserves only the executable distinction for regular files. Canonicalizing
+// the remaining bits keeps digests stable across checkout and copy umasks.
+const canonicalFileMode = (mode: number): number => ((mode & 0o111) === 0 ? 0o644 : 0o755);
+
 const frame = (value: string | Uint8Array): Uint8Array => {
   const bytes = typeof value === "string" ? textEncoder.encode(value) : value;
   const framed = new Uint8Array(4 + bytes.length);
+
   new DataView(framed.buffer).setUint32(0, bytes.length);
   framed.set(bytes, 4);
+
   return framed;
 };
 
 const concatenate = (chunks: ReadonlyArray<Uint8Array>): Uint8Array => {
   const combined = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.length, 0));
   let offset = 0;
+
   for (const chunk of chunks) {
     combined.set(chunk, offset);
     offset += chunk.length;
   }
+
   return combined;
 };
 
@@ -48,10 +54,13 @@ const compareUtf8 = (left: string, right: string): number => {
   const leftBytes = textEncoder.encode(left);
   const rightBytes = textEncoder.encode(right);
   const sharedLength = Math.min(leftBytes.length, rightBytes.length);
+
   for (let index = 0; index < sharedLength; index += 1) {
     const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+
     if (difference !== 0) return difference;
   }
+
   return leftBytes.length - rightBytes.length;
 };
 
@@ -60,12 +69,17 @@ const digestFrames = Effect.fn("digestPathFrames")(function* (
 ) {
   const crypto = yield* Crypto.Crypto;
   const digest = yield* crypto.digest("SHA-256", concatenate(values.map(frame)));
+
   return `sha256:${Encoding.encodeHex(digest)}`;
 });
 
 const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
   absolutePath: string,
-): Effect.fn.Return<ObservedPath, PlatformError.PlatformError | PathInspectionError, FileSystem.FileSystem | Path.Path | Crypto.Crypto> {
+): Effect.fn.Return<
+  ObservedPath,
+  PlatformError.PlatformError | PathInspectionError,
+  FileSystem.FileSystem | Path.Path | Crypto.Crypto
+> {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const symbolicLink = yield* observeSymbolicLink(absolutePath);
@@ -78,11 +92,14 @@ const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
     };
   }
 
-  const info = yield* fs.stat(absolutePath).pipe(
-    Effect.catch((error) =>
-      error.reason._tag === "NotFound" ? Effect.void : Effect.fail(error),
-    ),
-  );
+  const info = yield* fs
+    .stat(absolutePath)
+    .pipe(
+      Effect.catch((error) =>
+        error.reason._tag === "NotFound" ? Effect.void : Effect.fail(error),
+      ),
+    );
+
   if (info === undefined) return { kind: "missing" };
 
   if (info.type === "File") {
@@ -90,7 +107,7 @@ const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
       kind: "file",
       digest: yield* digestFrames([
         "file-v1",
-        String(info.mode & 0o777),
+        String(canonicalFileMode(info.mode)),
         yield* fs.readFile(absolutePath),
       ]),
     };
@@ -99,9 +116,11 @@ const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
   if (info.type === "Directory") {
     const entries = (yield* fs.readDirectory(absolutePath)).sort(compareUtf8);
     const frames: Array<string | Uint8Array> = ["directory-v1"];
+
     for (const entry of entries) {
       const childPath = path.join(absolutePath, entry);
       const child = yield* digestFileSystemPath(childPath);
+
       if (child.kind === "missing") {
         return yield* new PathInspectionError({
           path: childPath,
@@ -111,6 +130,7 @@ const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
       }
       frames.push(entry, child.kind, child.digest);
     }
+
     return { kind: "directory", digest: yield* digestFrames(frames) };
   }
 
@@ -135,6 +155,13 @@ export const digestText = Effect.fn("digestText")(function* (value: string) {
   return yield* digestFrames(["text-v1", value]);
 });
 
+export const digestFileContent = Effect.fn("digestFileContent")(function* (
+  value: string,
+  mode = 0o644,
+) {
+  return yield* digestFrames(["file-v1", String(canonicalFileMode(mode)), value]);
+});
+
 export const digestSymlinkTarget = Effect.fn("digestSymlinkTarget")(function* (target: string) {
   return yield* digestFrames(["symlink-v1", target]);
 });

package/src/project-package.ts

@@ -0,0 +1,59 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+
+export class ProjectPackageError extends Schema.TaggedErrorClass<ProjectPackageError>()(
+  "ProjectPackageError",
+  { message: Schema.String },
+) {}
+
+const ProjectPackageSchema = Schema.fromJsonString(
+  Schema.Struct({
+    name: Schema.optional(Schema.String),
+    scripts: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    dependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    devDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    optionalDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    peerDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  }),
+);
+
+export const readProjectPackage = Effect.fn("readProjectPackage")(function* (projectDir: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const manifestPath = path.join(projectDir, "package.json");
+
+  if (!(yield* fs.exists(manifestPath))) {
+    return yield* new ProjectPackageError({ message: `package.json not found: ${manifestPath}` });
+  }
+  const manifest = yield* fs.readFileString(manifestPath).pipe(
+    Effect.flatMap(Schema.decodeUnknownEffect(ProjectPackageSchema)),
+    Effect.mapError(
+      () =>
+        new ProjectPackageError({
+          message: `invalid project package.json: ${manifestPath}`,
+        }),
+    ),
+  );
+
+  return manifest;
+});
+
+export const readDirectDependencyNames = Effect.fn("readDirectDependencyNames")(function* (
+  projectDir: string,
+) {
+  const manifest = yield* readProjectPackage(projectDir).pipe(
+    Effect.catchTag("ProjectPackageError", (error) =>
+      error.message.startsWith("package.json not found:") ? Effect.void : Effect.fail(error),
+    ),
+  );
+
+  if (manifest === undefined) return [];
+
+  return [
+    ...new Set([
+      ...Object.keys(manifest.dependencies ?? {}),
+      ...Object.keys(manifest.devDependencies ?? {}),
+      ...Object.keys(manifest.optionalDependencies ?? {}),
+      ...Object.keys(manifest.peerDependencies ?? {}),
+    ]),
+  ].sort();
+});

package/src/project-process-lock.ts

@@ -38,15 +38,18 @@ export const acquireProjectProcessLock = Effect.fn("acquireProjectProcessLock")(
   return yield* Effect.acquireRelease(
     Effect.gen(function* () {
       yield* fs.makeDirectory(stateDir, { recursive: true });
+
       return yield* Effect.uninterruptible(
         Effect.gen(function* () {
-          yield* fs.makeDirectory(lockDir).pipe(
-            Effect.mapError((error) =>
-              error.reason._tag === "AlreadyExists"
-                ? new ProjectAlreadyLockedError({ path: lockDir })
-                : error,
-            ),
-          );
+          yield* fs
+            .makeDirectory(lockDir)
+            .pipe(
+              Effect.mapError((error) =>
+                error.reason._tag === "AlreadyExists"
+                  ? new ProjectAlreadyLockedError({ path: lockDir })
+                  : error,
+              ),
+            );
           yield* fs.writeFileString(ownerPath, ownerContents).pipe(
             Effect.catchCause((writeCause) =>
               fs.remove(lockDir, { recursive: true, force: true }).pipe(
@@ -57,17 +60,21 @@ export const acquireProjectProcessLock = Effect.fn("acquireProjectProcessLock")(
               ),
             ),
           );
+
           return { lockDir, ownerContents };
         }),
       );
     }),
     ({ lockDir: acquiredLockDir, ownerContents }) =>
       Effect.gen(function* () {
-        const currentOwner = yield* fs.readFileString(ownerPath).pipe(
-          Effect.catch((error) =>
-            error.reason._tag === "NotFound" ? Effect.void : Effect.fail(error),
-          ),
-        );
+        const currentOwner = yield* fs
+          .readFileString(ownerPath)
+          .pipe(
+            Effect.catch((error) =>
+              error.reason._tag === "NotFound" ? Effect.void : Effect.fail(error),
+            ),
+          );
+
         if (currentOwner === ownerContents) {
           yield* fs.remove(acquiredLockDir, { recursive: true, force: true });
         }

package/src/project-state.ts

@@ -29,7 +29,17 @@ export const ManagedSkillOutputSchema = Schema.Struct({
 });
 export type ManagedSkillOutput = typeof ManagedSkillOutputSchema.Type;
 
-export const ManagedInstructionOutputSchema = Schema.Struct({
+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,
@@ -37,11 +47,28 @@ export const ManagedInstructionOutputSchema = Schema.Struct({
   kind: Schema.Literal("symlink"),
   digest: DigestSchema,
 });
+export type ManagedClaudeInstructionsOutput = typeof ManagedClaudeInstructionsOutputSchema.Type;
+
+export const ManagedGeneratedFileOutputSchema = Schema.Struct({
+  resourceId: Schema.Literals(["setup:vite-plus-config", "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;
 
@@ -79,7 +106,7 @@ export const OwnershipReceiptSchema = Schema.Struct({
   resourceId: Schema.String,
   path: Schema.String,
   mode: Schema.Literals(["copy", "symlink"]),
-  kind: Schema.Literals(["directory", "symlink"]),
+  kind: Schema.Literals(["file", "directory", "symlink"]),
   digest: DigestSchema,
 });
 export type OwnershipReceipt = typeof OwnershipReceiptSchema.Type;