@stackweld/registry 0.2.0

package/dist/schema.d.ts

@@ -0,0 +1,147 @@
+/**
+ * JSON Schema for technology YAML files.
+ * Validated with ajv on load.
+ */
+export declare const technologySchema: {
+  readonly type: "object";
+  readonly required: readonly [
+    "id",
+    "name",
+    "category",
+    "description",
+    "website",
+    "versions",
+    "defaultVersion",
+    "requires",
+    "incompatibleWith",
+    "suggestedWith",
+    "envVars",
+    "configFiles",
+    "lastVerified",
+    "tags",
+  ];
+  readonly properties: {
+    readonly id: {
+      readonly type: "string";
+      readonly pattern: "^[a-z][a-z0-9-]*$";
+    };
+    readonly name: {
+      readonly type: "string";
+      readonly minLength: 1;
+    };
+    readonly category: {
+      readonly type: "string";
+      readonly enum: readonly [
+        "runtime",
+        "frontend",
+        "backend",
+        "database",
+        "orm",
+        "auth",
+        "styling",
+        "service",
+        "devops",
+      ];
+    };
+    readonly description: {
+      readonly type: "string";
+    };
+    readonly website: {
+      readonly type: "string";
+    };
+    readonly versions: {
+      readonly type: "array";
+      readonly minItems: 1;
+      readonly items: {
+        readonly type: "object";
+        readonly required: readonly ["version"];
+        readonly properties: {
+          readonly version: {
+            readonly type: "string";
+          };
+          readonly eol: {
+            readonly type: "string";
+          };
+          readonly lts: {
+            readonly type: "boolean";
+          };
+        };
+      };
+    };
+    readonly defaultVersion: {
+      readonly type: "string";
+    };
+    readonly defaultPort: {
+      readonly type: "integer";
+      readonly minimum: 1;
+      readonly maximum: 65535;
+    };
+    readonly requires: {
+      readonly type: "array";
+      readonly items: {
+        readonly type: "string";
+      };
+    };
+    readonly incompatibleWith: {
+      readonly type: "array";
+      readonly items: {
+        readonly type: "string";
+      };
+    };
+    readonly suggestedWith: {
+      readonly type: "array";
+      readonly items: {
+        readonly type: "string";
+      };
+    };
+    readonly officialScaffold: {
+      readonly type: readonly ["string", "null"];
+    };
+    readonly dockerImage: {
+      readonly type: readonly ["string", "null"];
+    };
+    readonly healthCheck: {
+      readonly type: "object";
+      readonly properties: {
+        readonly command: {
+          readonly type: "string";
+        };
+        readonly endpoint: {
+          readonly type: "string";
+        };
+        readonly interval: {
+          readonly type: "string";
+        };
+        readonly timeout: {
+          readonly type: "string";
+        };
+        readonly retries: {
+          readonly type: "integer";
+        };
+      };
+    };
+    readonly envVars: {
+      readonly type: "object";
+      readonly additionalProperties: {
+        readonly type: "string";
+      };
+    };
+    readonly configFiles: {
+      readonly type: "array";
+      readonly items: {
+        readonly type: "string";
+      };
+    };
+    readonly lastVerified: {
+      readonly type: "string";
+    };
+    readonly tags: {
+      readonly type: "array";
+      readonly items: {
+        readonly type: "string";
+      };
+    };
+  };
+  readonly additionalProperties: false;
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEnB,CAAC"}

package/dist/schema.js

@@ -0,0 +1,79 @@
+/**
+ * JSON Schema for technology YAML files.
+ * Validated with ajv on load.
+ */
+export const technologySchema = {
+    type: "object",
+    required: [
+        "id",
+        "name",
+        "category",
+        "description",
+        "website",
+        "versions",
+        "defaultVersion",
+        "requires",
+        "incompatibleWith",
+        "suggestedWith",
+        "envVars",
+        "configFiles",
+        "lastVerified",
+        "tags",
+    ],
+    properties: {
+        id: { type: "string", pattern: "^[a-z][a-z0-9-]*$" },
+        name: { type: "string", minLength: 1 },
+        category: {
+            type: "string",
+            enum: [
+                "runtime",
+                "frontend",
+                "backend",
+                "database",
+                "orm",
+                "auth",
+                "styling",
+                "service",
+                "devops",
+            ],
+        },
+        description: { type: "string" },
+        website: { type: "string" },
+        versions: {
+            type: "array",
+            minItems: 1,
+            items: {
+                type: "object",
+                required: ["version"],
+                properties: {
+                    version: { type: "string" },
+                    eol: { type: "string" },
+                    lts: { type: "boolean" },
+                },
+            },
+        },
+        defaultVersion: { type: "string" },
+        defaultPort: { type: "integer", minimum: 1, maximum: 65535 },
+        requires: { type: "array", items: { type: "string" } },
+        incompatibleWith: { type: "array", items: { type: "string" } },
+        suggestedWith: { type: "array", items: { type: "string" } },
+        officialScaffold: { type: ["string", "null"] },
+        dockerImage: { type: ["string", "null"] },
+        healthCheck: {
+            type: "object",
+            properties: {
+                command: { type: "string" },
+                endpoint: { type: "string" },
+                interval: { type: "string" },
+                timeout: { type: "string" },
+                retries: { type: "integer" },
+            },
+        },
+        envVars: { type: "object", additionalProperties: { type: "string" } },
+        configFiles: { type: "array", items: { type: "string" } },
+        lastVerified: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+    },
+    additionalProperties: false,
+};
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE;QACR,IAAI;QACJ,MAAM;QACN,UAAU;QACV,aAAa;QACb,SAAS;QACT,UAAU;QACV,gBAAgB;QAChB,UAAU;QACV,kBAAkB;QAClB,eAAe;QACf,SAAS;QACT,aAAa;QACb,cAAc;QACd,MAAM;KACP;IACD,UAAU,EAAE;QACV,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,mBAAmB,EAAE;QACpD,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE;QACtC,QAAQ,EAAE;YACR,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE;gBACJ,SAAS;gBACT,UAAU;gBACV,SAAS;gBACT,UAAU;gBACV,KAAK;gBACL,MAAM;gBACN,SAAS;gBACT,SAAS;gBACT,QAAQ;aACT;SACF;QACD,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC/B,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC3B,QAAQ,EAAE;YACR,IAAI,EAAE,OAAO;YACb,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,CAAC,SAAS,CAAC;gBACrB,UAAU,EAAE;oBACV,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAC3B,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBACvB,GAAG,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;iBACzB;aACF;SACF;QACD,cAAc,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAClC,WAAW,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE;QAC5D,QAAQ,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QACtD,gBAAgB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QAC9D,aAAa,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QAC3D,gBAAgB,EAAE,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE;QAC9C,WAAW,EAAE,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE;QACzC,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAC3B,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAC5B,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAC5B,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAC3B,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;aAC7B;SACF;QACD,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QACrE,WAAW,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QACzD,YAAY,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAChC,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;KACnD;IACD,oBAAoB,EAAE,KAAK;CACnB,CAAC"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@stackweld/registry",
+  "version": "0.2.0",
+  "description": "Technology registry for Stackweld — 83 YAML technology definitions with JSON Schema validation.",
+  "license": "MIT",
+  "author": "Orlando Fernandez <hello@xplustechnologies.com>",
+  "homepage": "https://github.com/mundowise/Stackweld",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mundowise/Stackweld.git",
+    "directory": "packages/registry"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "clean": "rm -rf dist .turbo"
+  },
+  "dependencies": {
+    "@stackweld/core": "workspace:*",
+    "ajv": "^8.17.0",
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.0.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.2"
+  }
+}

package/src/__tests__/loader.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from "vitest";
+import { listTechnologyIds, loadAllTechnologies, loadTechnology } from "../loader.js";
+
+describe("Registry Loader", () => {
+  it("loads all 50 technologies", () => {
+    const techs = loadAllTechnologies();
+    expect(techs.length).toBeGreaterThanOrEqual(80);
+  });
+
+  it("every technology has required fields", () => {
+    const techs = loadAllTechnologies();
+    for (const tech of techs) {
+      expect(tech.id).toBeTruthy();
+      expect(tech.name).toBeTruthy();
+      expect(tech.category).toBeTruthy();
+      expect(tech.versions.length).toBeGreaterThan(0);
+      expect(tech.defaultVersion).toBeTruthy();
+      expect(Array.isArray(tech.requires)).toBe(true);
+      expect(Array.isArray(tech.incompatibleWith)).toBe(true);
+      expect(Array.isArray(tech.suggestedWith)).toBe(true);
+      expect(Array.isArray(tech.tags)).toBe(true);
+    }
+  });
+
+  it("loads a specific technology by ID", () => {
+    const tech = loadTechnology("nextjs");
+    expect(tech).not.toBeNull();
+    expect(tech?.name).toBe("Next.js");
+    expect(tech?.category).toBe("frontend");
+    expect(tech?.requires).toContain("nodejs");
+  });
+
+  it("returns null for unknown technology", () => {
+    const tech = loadTechnology("nonexistent");
+    expect(tech).toBeNull();
+  });
+
+  it("lists all technology IDs", () => {
+    const ids = listTechnologyIds();
+    expect(ids.length).toBeGreaterThanOrEqual(80);
+    expect(ids).toContain("nextjs");
+    expect(ids).toContain("postgresql");
+    expect(ids).toContain("prisma");
+    expect(ids).toContain("tailwindcss");
+  });
+
+  it("has no broken cross-references", () => {
+    const techs = loadAllTechnologies();
+    const idSet = new Set(techs.map((t) => t.id));
+
+    for (const tech of techs) {
+      for (const ref of [...tech.requires, ...tech.incompatibleWith, ...tech.suggestedWith]) {
+        expect(idSet.has(ref), `${tech.id} references unknown "${ref}"`).toBe(true);
+      }
+    }
+  });
+
+  it("covers all 9 categories", () => {
+    const techs = loadAllTechnologies();
+    const categories = new Set(techs.map((t) => t.category));
+    expect(categories).toContain("runtime");
+    expect(categories).toContain("frontend");
+    expect(categories).toContain("backend");
+    expect(categories).toContain("database");
+    expect(categories).toContain("orm");
+    expect(categories).toContain("auth");
+    expect(categories).toContain("styling");
+    expect(categories).toContain("service");
+    expect(categories).toContain("devops");
+  });
+
+  it("incompatibleWith is symmetric", () => {
+    const techs = loadAllTechnologies();
+    const techMap = new Map(techs.map((t) => [t.id, t]));
+
+    for (const tech of techs) {
+      for (const incompId of tech.incompatibleWith) {
+        const other = techMap.get(incompId);
+        if (other) {
+          expect(
+            other.incompatibleWith.includes(tech.id),
+            `${tech.id} says incompatible with ${incompId}, but ${incompId} doesn't list ${tech.id}`,
+          ).toBe(true);
+        }
+      }
+    }
+  });
+
+  it("all technologies have unique IDs", () => {
+    const techs = loadAllTechnologies();
+    const ids = techs.map((t) => t.id);
+    const uniqueIds = new Set(ids);
+    expect(
+      uniqueIds.size,
+      `Found duplicate IDs: ${ids.filter((id, i) => ids.indexOf(id) !== i).join(", ")}`,
+    ).toBe(ids.length);
+  });
+
+  it("all requires references point to existing technology IDs", () => {
+    const techs = loadAllTechnologies();
+    const idSet = new Set(techs.map((t) => t.id));
+
+    for (const tech of techs) {
+      for (const reqId of tech.requires) {
+        expect(
+          idSet.has(reqId),
+          `${tech.id} requires "${reqId}" which does not exist in the registry`,
+        ).toBe(true);
+      }
+    }
+  });
+
+  it("all incompatibleWith references point to existing technology IDs", () => {
+    const techs = loadAllTechnologies();
+    const idSet = new Set(techs.map((t) => t.id));
+
+    for (const tech of techs) {
+      for (const incompId of tech.incompatibleWith) {
+        expect(
+          idSet.has(incompId),
+          `${tech.id} lists incompatibleWith "${incompId}" which does not exist in the registry`,
+        ).toBe(true);
+      }
+    }
+  });
+
+  it("no technology is incompatible with itself", () => {
+    const techs = loadAllTechnologies();
+
+    for (const tech of techs) {
+      expect(
+        tech.incompatibleWith.includes(tech.id),
+        `${tech.id} is listed as incompatible with itself`,
+      ).toBe(false);
+    }
+  });
+
+  it("all technologies have at least one version defined", () => {
+    const techs = loadAllTechnologies();
+
+    for (const tech of techs) {
+      expect(tech.versions.length, `${tech.id} has no versions defined`).toBeGreaterThan(0);
+    }
+  });
+
+  it("bidirectional incompatibilities are symmetric (if A lists B, B lists A)", () => {
+    const techs = loadAllTechnologies();
+    const techMap = new Map(techs.map((t) => [t.id, t]));
+    const asymmetric: string[] = [];
+
+    for (const tech of techs) {
+      for (const incompId of tech.incompatibleWith) {
+        const other = techMap.get(incompId);
+        if (other && !other.incompatibleWith.includes(tech.id)) {
+          asymmetric.push(`${tech.id} -> ${incompId}`);
+        }
+      }
+    }
+
+    expect(asymmetric, `Asymmetric incompatibilities found: ${asymmetric.join(", ")}`).toEqual([]);
+  });
+});

package/src/index.ts

@@ -0,0 +1,4 @@
+export type { LearningResource } from "./learning-resources.js";
+export { getLearningResources, LEARNING_RESOURCES } from "./learning-resources.js";
+export { listTechnologyIds, loadAllTechnologies, loadTechnology } from "./loader.js";
+export { technologySchema } from "./schema.js";