flingit 0.0.63 → 0.0.65

package/node_modules/flingflow/test/store-conformance.ts

@@ -0,0 +1,344 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { UniqueConstraintError, WorkflowAlreadyActiveError, WorkflowIdMismatchError, type EventStore } from "../src/store.js";
+import type { WorkflowConfig, WorkflowEvent } from "../src/types.js";
+import { noSim } from "./fixtures.js";
+
+const TEST_CONFIG: WorkflowConfig = { maxAttempts: 5, initialBackoffMS: 1000, backoffMultiplier: 2, maxBackoffMS: 60_000, stepTimeoutMS: 300_000 };
+
+export function storeConformanceTests(name: string, createStore: () => Promise<EventStore>) {
+  describe(`${name} conformance`, () => {
+    let store: EventStore;
+
+    beforeEach(async () => {
+      store = await createStore();
+    });
+
+    it("append + getLastEvent round-trip", async () => {
+      const event: WorkflowEvent = {
+        run_id: "run-1", workflow_id: "wf-1",
+        seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: { userId: 42 }, config: TEST_CONFIG },
+        created_at: 1000,
+      };
+
+      const result = await store.append(event, noSim);
+      expect(result.isOk()).toBe(true);
+      const last = (await store.getLastEvent("run-1", noSim))._unsafeUnwrap();
+      expect(last).toEqual(event);
+    });
+
+    it("getLastEvent returns null for unknown run", async () => {
+      const last = (await store.getLastEvent("nonexistent", noSim))._unsafeUnwrap();
+      expect(last).toBeNull();
+    });
+
+    it("getLastEvent returns highest seq", async () => {
+      (await store.append({
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+      (await store.append({
+        run_id: "run-1", workflow_id: "wf-1", seq: 1, event_type: "step_started",
+        payload: { step: "start", attempt: 1 }, created_at: 1001,
+      }, noSim))._unsafeUnwrap();
+
+      const last = (await store.getLastEvent("run-1", noSim))._unsafeUnwrap();
+      expect(last!.seq).toBe(1);
+      expect(last!.event_type).toBe("step_started");
+    });
+
+    it("returns UniqueConstraintError on duplicate (run_id, seq)", async () => {
+      const event: WorkflowEvent = {
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      };
+      (await store.append(event, noSim))._unsafeUnwrap();
+      const result = await store.append(event, noSim);
+      expect(result.isErr()).toBe(true);
+      expect(result._unsafeUnwrapErr()).toBeInstanceOf(UniqueConstraintError);
+    });
+
+    it("appendBatch inserts multiple events atomically", async () => {
+      const events: WorkflowEvent[] = [
+        { run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+      ];
+
+      const result = await store.appendBatch(events, noSim);
+      expect(result.isOk()).toBe(true);
+      const all = (await store.getAllEvents("run-1", noSim))._unsafeUnwrap();
+      expect(all).toHaveLength(2);
+    });
+
+    it("appendBatch is atomic — no partial inserts on duplicate", async () => {
+      (await store.append({
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+
+      const events: WorkflowEvent[] = [
+        { run_id: "run-1", workflow_id: "wf-1", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 }, // dup
+      ];
+
+      const result = await store.appendBatch(events, noSim);
+      expect(result.isErr()).toBe(true);
+      expect(result._unsafeUnwrapErr()).toBeInstanceOf(UniqueConstraintError);
+
+      // seq=1 should NOT be present since batch is atomic
+      const all = (await store.getAllEvents("run-1", noSim))._unsafeUnwrap();
+      expect(all).toHaveLength(1);
+      expect(all[0].seq).toBe(0);
+    });
+
+    it("getEvent returns specific event", async () => {
+      (await store.append({
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: { x: 1 }, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+
+      const event = (await store.getEvent("run-1", 0, noSim))._unsafeUnwrap();
+      expect(event).not.toBeNull();
+      expect(event!.event_type).toBe("workflow_created");
+      expect((event!.payload as any).writes).toEqual({ x: 1 });
+    });
+
+    it("getEvent returns null for missing seq", async () => {
+      const event = (await store.getEvent("run-1", 99, noSim))._unsafeUnwrap();
+      expect(event).toBeNull();
+    });
+
+    it("getCompletedEvents returns step_completed events in seq DESC order", async () => {
+      (await store.appendBatch([
+        { run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 2, event_type: "step_completed", payload: { step: "start", writes: { a: 1 }, next_step: "two" }, created_at: 1002 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 3, event_type: "step_started", payload: { step: "two", attempt: 1 }, created_at: 1003 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 4, event_type: "step_completed", payload: { step: "two", writes: { b: 2 } }, created_at: 1004 },
+      ], noSim))._unsafeUnwrap();
+
+      const completed = (await store.getCompletedEvents("run-1", noSim))._unsafeUnwrap();
+      expect(completed).toHaveLength(2);
+      expect(completed[0].seq).toBe(4); // newest first
+      expect(completed[1].seq).toBe(2);
+    });
+
+    it("getAllEvents returns events in seq ASC order", async () => {
+      (await store.appendBatch([
+        { run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+      ], noSim))._unsafeUnwrap();
+
+      const all = (await store.getAllEvents("run-1", noSim))._unsafeUnwrap();
+      expect(all).toHaveLength(2);
+      expect(all[0].seq).toBe(0);
+      expect(all[1].seq).toBe(1);
+    });
+
+    it("getActiveWorkflows excludes terminal workflows", async () => {
+      // Active workflow
+      (await store.append({
+        run_id: "run-active", workflow_id: "wf-active", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+
+      // Completed workflow
+      (await store.appendBatch([
+        { run_id: "run-done", workflow_id: "wf-done", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-done", workflow_id: "wf-done", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+        { run_id: "run-done", workflow_id: "wf-done", seq: 2, event_type: "step_completed", payload: { step: "start", writes: {} }, created_at: 1002 },
+        { run_id: "run-done", workflow_id: "wf-done", seq: 3, event_type: "workflow_completed", payload: { result: "ok" }, created_at: 1003 },
+      ], noSim))._unsafeUnwrap();
+
+      // Failed workflow
+      (await store.appendBatch([
+        { run_id: "run-fail", workflow_id: "wf-fail", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-fail", workflow_id: "wf-fail", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+        { run_id: "run-fail", workflow_id: "wf-fail", seq: 2, event_type: "step_failed", payload: { step: "start", attempt: 1, reason: "boom", retryable: false }, created_at: 1002 },
+        { run_id: "run-fail", workflow_id: "wf-fail", seq: 3, event_type: "workflow_failed", payload: { reason: "boom", cause: "non_retryable" }, created_at: 1003 },
+      ], noSim))._unsafeUnwrap();
+
+      const active = (await store.getActiveWorkflows(noSim))._unsafeUnwrap();
+      expect(active).toHaveLength(1);
+      expect(active[0].run_id).toBe("run-active");
+    });
+
+    it("JSON round-trips payloads correctly", async () => {
+      const payload = {
+        workflowName: "test",
+        writes: { nested: { arr: [1, "two", null, true], num: 3.14 } },
+        config: TEST_CONFIG,
+      };
+      (await store.append({
+        run_id: "run-json", workflow_id: "wf-json", seq: 0, event_type: "workflow_created",
+        payload, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+
+      const retrieved = (await store.getEvent("run-json", 0, noSim))._unsafeUnwrap();
+      expect(retrieved!.payload).toEqual(payload);
+      expect(retrieved!.payload).not.toBe(payload);
+    });
+
+    it("isolates events between different runs", async () => {
+      (await store.append({
+        run_id: "run-a", workflow_id: "wf-a", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "a", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+      (await store.append({
+        run_id: "run-b", workflow_id: "wf-b", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "b", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+
+      const allA = (await store.getAllEvents("run-a", noSim))._unsafeUnwrap();
+      const allB = (await store.getAllEvents("run-b", noSim))._unsafeUnwrap();
+      expect(allA).toHaveLength(1);
+      expect(allB).toHaveLength(1);
+      expect((allA[0].payload as any).workflowName).toBe("a");
+      expect((allB[0].payload as any).workflowName).toBe("b");
+    });
+
+    // --- appendIfNoActiveWorkflow tests ---
+
+    it("appendIfNoActiveWorkflow succeeds when no active run", async () => {
+      const event: WorkflowEvent = {
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      };
+      const result = await store.appendIfNoActiveWorkflow("wf-1", event, noSim);
+      expect(result.isOk()).toBe(true);
+
+      const last = (await store.getLastEvent("run-1", noSim))._unsafeUnwrap();
+      expect(last).toEqual(event);
+    });
+
+    it("appendIfNoActiveWorkflow rejects when active run exists", async () => {
+      (await store.appendIfNoActiveWorkflow("wf-1", {
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+
+      const result = await store.appendIfNoActiveWorkflow("wf-1", {
+        run_id: "run-2", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 2000,
+      }, noSim);
+
+      expect(result.isErr()).toBe(true);
+      expect(result._unsafeUnwrapErr()).toBeInstanceOf(WorkflowAlreadyActiveError);
+    });
+
+    it("appendIfNoActiveWorkflow allows after terminal event", async () => {
+      // Create and complete a workflow
+      (await store.appendIfNoActiveWorkflow("wf-1", {
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+      (await store.appendBatch([
+        { run_id: "run-1", workflow_id: "wf-1", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 2, event_type: "step_completed", payload: { step: "start", writes: {} }, created_at: 1002 },
+        { run_id: "run-1", workflow_id: "wf-1", seq: 3, event_type: "workflow_completed", payload: { result: "ok" }, created_at: 1003 },
+      ], noSim))._unsafeUnwrap();
+
+      // Now a new run with the same workflow_id should succeed
+      const result = await store.appendIfNoActiveWorkflow("wf-1", {
+        run_id: "run-2", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 2000,
+      }, noSim);
+      expect(result.isOk()).toBe(true);
+    });
+
+    // --- getRecentRuns tests ---
+
+    it("getRecentRuns returns workflow_created events ordered by created_at DESC", async () => {
+      (await store.appendBatch([
+        { run_id: "run-old", workflow_id: "wf-old", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-old", workflow_id: "wf-old", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+        { run_id: "run-old", workflow_id: "wf-old", seq: 2, event_type: "step_completed", payload: { step: "start", writes: {} }, created_at: 1002 },
+        { run_id: "run-old", workflow_id: "wf-old", seq: 3, event_type: "workflow_completed", payload: { result: "ok" }, created_at: 1003 },
+      ], noSim))._unsafeUnwrap();
+
+      (await store.append({
+        run_id: "run-new", workflow_id: "wf-new", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 2000,
+      }, noSim))._unsafeUnwrap();
+
+      (await store.append({
+        run_id: "run-mid", workflow_id: "wf-mid", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1500,
+      }, noSim))._unsafeUnwrap();
+
+      const runs = (await store.getRecentRuns(10, noSim))._unsafeUnwrap();
+      expect(runs).toHaveLength(3);
+      expect(runs[0].run_id).toBe("run-new");
+      expect(runs[1].run_id).toBe("run-mid");
+      expect(runs[2].run_id).toBe("run-old");
+      // All should be seq=0 (workflow_created)
+      for (const run of runs) {
+        expect(run.seq).toBe(0);
+        expect(run.event_type).toBe("workflow_created");
+      }
+    });
+
+    it("getRecentRuns respects limit", async () => {
+      (await store.append({
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+      (await store.append({
+        run_id: "run-2", workflow_id: "wf-2", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 2000,
+      }, noSim))._unsafeUnwrap();
+      (await store.append({
+        run_id: "run-3", workflow_id: "wf-3", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 3000,
+      }, noSim))._unsafeUnwrap();
+
+      const runs = (await store.getRecentRuns(2, noSim))._unsafeUnwrap();
+      expect(runs).toHaveLength(2);
+      expect(runs[0].run_id).toBe("run-3");
+      expect(runs[1].run_id).toBe("run-2");
+    });
+
+    it("getRecentRuns returns empty array when no runs exist", async () => {
+      const runs = (await store.getRecentRuns(10, noSim))._unsafeUnwrap();
+      expect(runs).toHaveLength(0);
+    });
+
+    it("getRecentRuns includes both active and completed workflows", async () => {
+      // Active workflow
+      (await store.append({
+        run_id: "run-active", workflow_id: "wf-active", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 2000,
+      }, noSim))._unsafeUnwrap();
+
+      // Completed workflow
+      (await store.appendBatch([
+        { run_id: "run-done", workflow_id: "wf-done", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-done", workflow_id: "wf-done", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 1001 },
+        { run_id: "run-done", workflow_id: "wf-done", seq: 2, event_type: "step_completed", payload: { step: "start", writes: {} }, created_at: 1002 },
+        { run_id: "run-done", workflow_id: "wf-done", seq: 3, event_type: "workflow_completed", payload: { result: "ok" }, created_at: 1003 },
+      ], noSim))._unsafeUnwrap();
+
+      const runs = (await store.getRecentRuns(10, noSim))._unsafeUnwrap();
+      expect(runs).toHaveLength(2);
+      // Both active and completed should appear
+      const runIds = runs.map(r => r.run_id);
+      expect(runIds).toContain("run-active");
+      expect(runIds).toContain("run-done");
+    });
+
+    it("rejects appending event with mismatched workflow_id for existing run_id", async () => {
+      (await store.append({
+        run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",
+        payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000,
+      }, noSim))._unsafeUnwrap();
+
+      const result = await store.append({
+        run_id: "run-1", workflow_id: "wf-WRONG", seq: 1, event_type: "step_started",
+        payload: { step: "start", attempt: 1 }, created_at: 1001,
+      }, noSim);
+
+      expect(result.isErr()).toBe(true);
+      expect(result._unsafeUnwrapErr()).toBeInstanceOf(WorkflowIdMismatchError);
+    });
+  });
+}

package/node_modules/flingflow/test/store-memory.test.ts

@@ -0,0 +1,8 @@
+import { storeConformanceTests } from "./store-conformance.js";
+import { MemoryEventStore } from "../src/store-memory.js";
+
+storeConformanceTests("MemoryEventStore", async () => {
+  const store = new MemoryEventStore();
+  (await store.initialize())._unsafeUnwrap();
+  return store;
+});

package/node_modules/flingflow/test/store-sqlite.test.ts

@@ -0,0 +1,8 @@
+import { storeConformanceTests } from "./store-conformance.js";
+import { SqliteEventStore } from "../src/store-sqlite.js";
+
+storeConformanceTests("SqliteEventStore", async () => {
+  const store = new SqliteEventStore(":memory:");
+  (await store.initialize())._unsafeUnwrap();
+  return store;
+});

package/node_modules/flingflow/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "test"]
+}

package/node_modules/flingflow/tsconfig.lint.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.typecheck.json",
+  "include": ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/node_modules/flingflow/tsconfig.typecheck.json

@@ -0,0 +1,20 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": ".",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/node_modules/flingflow/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+    exclude: ["**/node_modules/**", "**/dist/**"],
+  },
+});

package/node_modules/fs-constants/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Mathias Buus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/fs-constants/README.md

@@ -0,0 +1,26 @@
+# fs-constants
+
+Small module that allows you to get the fs constants across
+Node and the browser. 
+
+```
+npm install fs-constants
+```
+
+Previously you would use `require('constants')` for this in node but that has been
+deprecated and changed to `require('fs').constants` which does not browserify.
+
+This module uses `require('constants')` in the browser and `require('fs').constants` in node to work around this
+
+
+## Usage
+
+``` js
+var constants = require('fs-constants')
+
+console.log('constants:', constants)
+```
+
+## License
+
+MIT

package/node_modules/fs-constants/browser.js

@@ -0,0 +1 @@
+module.exports = require('constants')

package/node_modules/fs-constants/index.js

@@ -0,0 +1 @@
+module.exports = require('fs').constants || require('constants')

package/node_modules/fs-constants/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "fs-constants",
+  "version": "1.0.0",
+  "description": "Require constants across node and the browser",
+  "main": "index.js",
+  "browser": "browser.js",
+  "dependencies": {},
+  "devDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mafintosh/fs-constants.git"
+  },
+  "author": "Mathias Buus (@mafintosh)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mafintosh/fs-constants/issues"
+  },
+  "homepage": "https://github.com/mafintosh/fs-constants"
+}

package/node_modules/github-from-package/.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - 0.6
+  - 0.8

package/node_modules/github-from-package/LICENSE

@@ -0,0 +1,18 @@
+This software is released under the MIT license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/github-from-package/example/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "beep-boop",
+  "version": "1.2.3",
+  "repository" : {
+    "type" : "git",
+    "url": "git@github.com:substack/beep-boop.git"
+  }
+}

package/node_modules/github-from-package/example/url.js

@@ -0,0 +1,3 @@
+var github = require('../');
+var url = github(require('./package.json'));
+console.log(url);

package/node_modules/github-from-package/index.js

@@ -0,0 +1,17 @@
+module.exports = function (pkg) {
+    var m;
+    if (m = match(JSON.stringify(pkg.repository))) {
+        return m;
+    }
+    else if (m = match(JSON.stringify(pkg))) {
+        return m;
+    }
+    return undefined;
+};
+
+function match (str) {
+    var m = /\bgithub.com[:\/]([^\/"]+)\/([^\/"]+)/.exec(str);
+    if (m) {
+        return 'https://github.com/' + m[1] + '/' + m[2].replace(/\.git$/, '');
+    }
+}

package/node_modules/github-from-package/package.json

@@ -0,0 +1,30 @@
+{
+    "name" : "github-from-package",
+    "version" : "0.0.0",
+    "description" : "return the github url from a package.json file",
+    "main" : "index.js",
+    "devDependencies" : {
+        "tap" : "~0.3.0",
+        "tape" : "~0.1.5"
+    },
+    "scripts" : {
+        "test" : "tap test/*.js"
+    },
+    "repository" : {
+        "type" : "git",
+        "url" : "git://github.com/substack/github-from-package.git"
+    },
+    "homepage" : "https://github.com/substack/github-from-package",
+    "keywords" : [
+        "github",
+        "package.json",
+        "npm",
+        "repository"
+    ],
+    "author" : {
+        "name" : "James Halliday",
+        "email" : "mail@substack.net",
+        "url" : "http://substack.net"
+    },
+    "license" : "MIT"
+}

package/node_modules/github-from-package/readme.markdown

@@ -0,0 +1,53 @@
+# github-from-package
+
+return the github url from a package.json file
+
+[![build status](https://secure.travis-ci.org/substack/github-from-package.png)](http://travis-ci.org/substack/github-from-package)
+
+# example
+
+For the `./package.json` file:
+
+``` json
+{
+  "name": "beep-boop",
+  "version": "1.2.3",
+  "repository" : {
+    "type" : "git",
+    "url": "git@github.com:substack/beep-boop.git"
+  }
+}
+```
+
+``` js
+var github = require('github-from-package');
+var url = github(require('./package.json'));
+console.log(url);
+```
+
+```
+https://github.com/substack/beep-boop
+```
+
+# methods
+
+``` js
+var github = require('github-from-package')
+```
+
+## var url = github(pkg)
+
+Return the most likely github url from the package.json contents `pkg`. If no
+github url can be determined, return `undefined`.
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install github-from-package
+```
+
+# license
+
+MIT

package/node_modules/github-from-package/test/a.json

@@ -0,0 +1,8 @@
+{
+  "name": "beep-boop",
+  "version": "1.2.3",
+  "repository" : {
+    "type" : "git",
+    "url": "git@github.com:substack/beep-boop.git"
+  }
+}

package/node_modules/github-from-package/test/b.json

@@ -0,0 +1,5 @@
+{
+  "name": "beep-boop",
+  "version": "1.2.3",
+  "repository" : "git@github.com:substack/beep-boop.git"
+}