@rigkit/engine 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/engine",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "repository": {
     "type": "git",

package/src/engine.test.ts

@@ -408,6 +408,56 @@ describe("DevMachineEngine workflow runtime", () => {
     });
   });
 
+  test("invalidates task cache when handler source changes", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-handler-cache-"));
+    const statePath = join(projectDir, ".rigkit", "state.sqlite");
+    mkdirSync(join(projectDir, ".rigkit"));
+    const writeConfig = (configPath: string, value: string) =>
+      writeFileSync(
+        configPath,
+        `
+          import { workflow } from "${import.meta.dir}/index.ts";
+
+          const app = workflow("handler-cache", { providers: {} });
+
+          export default app.sequence("root").task("value", async () => {
+            return { value: "${value}" };
+          });
+        `,
+      );
+
+    const firstConfigPath = join(projectDir, "rig.one.config.ts");
+    const secondConfigPath = join(projectDir, "rig.two.config.ts");
+    writeConfig(firstConfigPath, "one");
+    writeConfig(secondConfigPath, "two");
+
+    const first = await createDevMachineEngine({
+      projectDir,
+      configPath: firstConfigPath,
+      statePath,
+    });
+    await first.load();
+    const applied = await first.apply();
+    expect(applied.context.value).toBe("one");
+
+    const cached = await first.plan();
+    expect(cached.cachedNodeCount).toBe(1);
+
+    const second = await createDevMachineEngine({
+      projectDir,
+      configPath: secondConfigPath,
+      statePath,
+    });
+    await second.load();
+    const changed = await second.plan();
+    expect(changed.cachedNodeCount).toBe(0);
+    expect(changed.nodes[0]?.status).toBe("pending");
+
+    const reapplied = await second.apply();
+    expect(reapplied.context.value).toBe("two");
+    expect(second.listNodeRuns()).toHaveLength(2);
+  });
+
   test("stores provider JSON state in Rigkit-owned provider storage", async () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-"));
     const plugin: BaseProviderPlugin = {

package/src/engine.ts

@@ -179,6 +179,8 @@ type RuntimeOperationEntry = {
   readonly run: (input: { workflow?: string; input?: unknown }) => Promise<unknown>;
 };
 
+let configImportCounter = 0;
+
 export class DevMachineEngine {
   private readonly projectDir: string;
   private readonly configPath: string;
@@ -226,7 +228,7 @@ export class DevMachineEngine {
     }
 
     const moduleUrl = pathToFileURL(this.configPath);
-    moduleUrl.searchParams.set("t", String(Date.now()));
+    moduleUrl.searchParams.set("t", `${Date.now()}-${configImportCounter++}`);
     const mod = await import(moduleUrl.href);
     const roots = normalizeDefinitions(mod.default ?? mod.workflow);
     const loaded = await Promise.all(roots.map((root) => this.resolveWorkflow(root)));
@@ -898,10 +900,13 @@ export class DevMachineEngine {
     const nodePath = [...input.prefix, input.node.name].join(".");
     const upstreamRunIds = [...input.state.upstreamRunIds];
     const nodeKey = hash({
+      cache: "task-v2",
       kind: "task",
       path: nodePath,
       name: input.node.name,
       version: input.node.options?.version ?? null,
+      handler: functionFingerprintFor(input.node.handler),
+      output: input.node.options?.output ?? null,
     });
     const planIndex = input.index.value++;
 
@@ -1673,18 +1678,36 @@ function collectNodePaths(root: WorkflowNodeDefinition<any, any, any>): string[]
 
 function providerFingerprintFor(workflow: LoadedWorkflow): string {
   return hash({
+    cache: "provider-v2",
     providers: Object.fromEntries(
       Object.entries(workflow.providers).map(([name, provider]) => [
         name,
         {
           providerId: provider.providerId,
           config: provider.config,
+          plugin: providerPluginFingerprint(provider.plugin),
         },
       ]),
     ),
   });
 }
 
+function providerPluginFingerprint(plugin: unknown): unknown {
+  if (!isBaseProviderPlugin(plugin)) return null;
+  return {
+    providerId: plugin.providerId,
+    createProvider: functionFingerprintFor(plugin.createProvider),
+  };
+}
+
+function functionFingerprintFor(fn: Function): { name: string; length: number; source: string } {
+  return {
+    name: fn.name,
+    length: fn.length,
+    source: Function.prototype.toString.call(fn),
+  };
+}
+
 function sequenceChildren(node: WorkflowNodeDefinition<any, any, any>): readonly WorkflowNodeDefinition<any, any, any>[] {
   return (node as { children?: readonly WorkflowNodeDefinition<any, any, any>[] }).children ?? [];
 }

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_ENGINE_VERSION = "0.2.0";
+export const RIGKIT_ENGINE_VERSION = "0.2.2";