@robotaccomplice/architext 1.0.0

package/docs/architext/tools/validate-architext.mjs

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function parseArgs(argv) {
+  const options = {
+    dataDir: path.join(root, "data"),
+    schemaDir: path.join(root, "schema")
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--data-dir") {
+      options.dataDir = path.resolve(argv[++index] ?? "");
+    } else if (arg === "--schema-dir") {
+      options.schemaDir = path.resolve(argv[++index] ?? "");
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+const options = parseArgs(process.argv.slice(2));
+const dataDir = options.dataDir;
+const schemaDir = options.schemaDir;
+
+const schemaFiles = {
+  manifest: "manifest.schema.json",
+  nodes: "nodes.schema.json",
+  flows: "flows.schema.json",
+  views: "views.schema.json",
+  dataClassification: "data-classification.schema.json",
+  decisions: "decisions.schema.json",
+  risks: "risks.schema.json",
+  glossary: "glossary.schema.json"
+};
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function requireUnique(items, label, errors) {
+  const seen = new Set();
+  for (const item of items) {
+    if (seen.has(item.id)) {
+      errors.push(`${label} contains duplicate id "${item.id}"`);
+    }
+    seen.add(item.id);
+  }
+}
+
+function requireKnown(id, known, context, errors) {
+  if (!known.has(id)) {
+    errors.push(`${context} references unknown id "${id}"`);
+  }
+}
+
+function validateReferences(model, errors) {
+  const nodeIds = new Set(model.nodes.nodes.map((node) => node.id));
+  const flowIds = new Set(model.flows.flows.map((flow) => flow.id));
+  const dataIds = new Set(model.dataClassification.classes.map((item) => item.id));
+  const decisionIds = new Set(model.decisions.decisions.map((item) => item.id));
+  const riskIds = new Set(model.risks.risks.map((item) => item.id));
+  const viewIds = new Set(model.views.views.map((item) => item.id));
+
+  requireKnown(model.manifest.defaultViewId, viewIds, "manifest.defaultViewId", errors);
+
+  for (const node of model.nodes.nodes) {
+    for (const dependencyId of node.dependencies) requireKnown(dependencyId, nodeIds, `node ${node.id}.dependencies`, errors);
+    for (const dataId of node.dataHandled) requireKnown(dataId, dataIds, `node ${node.id}.dataHandled`, errors);
+    for (const flowId of node.relatedFlows) requireKnown(flowId, flowIds, `node ${node.id}.relatedFlows`, errors);
+    for (const decisionId of node.relatedDecisions) requireKnown(decisionId, decisionIds, `node ${node.id}.relatedDecisions`, errors);
+    for (const riskId of node.knownRisks) requireKnown(riskId, riskIds, `node ${node.id}.knownRisks`, errors);
+  }
+
+  for (const flow of model.flows.flows) {
+    for (const actorId of flow.actors) requireKnown(actorId, nodeIds, `flow ${flow.id}.actors`, errors);
+    const stepIds = new Set();
+    for (const step of flow.steps) {
+      if (stepIds.has(step.id)) errors.push(`flow ${flow.id} contains duplicate step id "${step.id}"`);
+      stepIds.add(step.id);
+      requireKnown(step.from, nodeIds, `flow ${flow.id} step ${step.id}.from`, errors);
+      requireKnown(step.to, nodeIds, `flow ${flow.id} step ${step.id}.to`, errors);
+      for (const dataId of step.data) requireKnown(dataId, dataIds, `flow ${flow.id} step ${step.id}.data`, errors);
+    }
+  }
+
+  for (const view of model.views.views) {
+    const laneIds = new Set();
+    for (const lane of view.lanes) {
+      if (laneIds.has(lane.id)) errors.push(`view ${view.id} contains duplicate lane id "${lane.id}"`);
+      laneIds.add(lane.id);
+      for (const nodeId of lane.nodeIds) requireKnown(nodeId, nodeIds, `view ${view.id} lane ${lane.id}`, errors);
+    }
+  }
+
+  for (const decision of model.decisions.decisions) {
+    for (const nodeId of decision.relatedNodes) requireKnown(nodeId, nodeIds, `decision ${decision.id}.relatedNodes`, errors);
+    for (const flowId of decision.relatedFlows) requireKnown(flowId, flowIds, `decision ${decision.id}.relatedFlows`, errors);
+  }
+
+  for (const risk of model.risks.risks) {
+    for (const nodeId of risk.relatedNodes) requireKnown(nodeId, nodeIds, `risk ${risk.id}.relatedNodes`, errors);
+    for (const flowId of risk.relatedFlows) requireKnown(flowId, flowIds, `risk ${risk.id}.relatedFlows`, errors);
+  }
+}
+
+const ajv = new Ajv2020({ allErrors: true, strict: true });
+addFormats(ajv);
+
+const schemas = Object.fromEntries(
+  Object.entries(schemaFiles).map(([key, file]) => [key, readJson(path.join(schemaDir, file))])
+);
+
+for (const schema of Object.values(schemas)) {
+  ajv.addSchema(schema);
+}
+
+const manifest = readJson(path.join(dataDir, "manifest.json"));
+const model = {
+  manifest,
+  nodes: readJson(path.join(dataDir, manifest.files.nodes)),
+  flows: readJson(path.join(dataDir, manifest.files.flows)),
+  views: readJson(path.join(dataDir, manifest.files.views)),
+  dataClassification: readJson(path.join(dataDir, manifest.files.dataClassification)),
+  decisions: readJson(path.join(dataDir, manifest.files.decisions)),
+  risks: readJson(path.join(dataDir, manifest.files.risks)),
+  glossary: readJson(path.join(dataDir, manifest.files.glossary))
+};
+
+const errors = [];
+
+for (const [key, schema] of Object.entries(schemas)) {
+  const validate = ajv.getSchema(schema.$id);
+  const value = key === "dataClassification" ? model.dataClassification : model[key];
+  if (!validate(value)) {
+    for (const error of validate.errors ?? []) {
+      errors.push(`${key}${error.instancePath}: ${error.message}`);
+    }
+  }
+}
+
+requireUnique(model.nodes.nodes, "nodes", errors);
+requireUnique(model.flows.flows, "flows", errors);
+requireUnique(model.views.views, "views", errors);
+requireUnique(model.dataClassification.classes, "dataClassification.classes", errors);
+requireUnique(model.decisions.decisions, "decisions", errors);
+requireUnique(model.risks.risks, "risks", errors);
+validateReferences(model, errors);
+
+if (errors.length > 0) {
+  console.error("Architext validation failed:");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Architext validation passed.");

package/docs/architext/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  },
+  "include": ["src"]
+}
+

package/docs/architext/vite.config.ts

@@ -0,0 +1,47 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const dataDir = process.env.ARCHITEXT_DATA_DIR;
+
+export default defineConfig({
+  plugins: [
+    react(),
+    {
+      name: "architext-target-data",
+      configureServer(server) {
+        if (!dataDir) return;
+        server.middlewares.use(async (request, response, next) => {
+          if (!request.url?.startsWith("/data/")) {
+            next();
+            return;
+          }
+
+          const relativePath = decodeURIComponent(request.url.slice("/data/".length).split("?")[0] ?? "");
+          const filePath = path.resolve(dataDir, relativePath);
+          const root = path.resolve(dataDir);
+
+          if (!filePath.startsWith(`${root}${path.sep}`)) {
+            response.statusCode = 403;
+            response.end("Forbidden");
+            return;
+          }
+
+          try {
+            const body = await fs.readFile(filePath);
+            response.setHeader("Content-Type", "application/json; charset=utf-8");
+            response.end(body);
+          } catch {
+            response.statusCode = 404;
+            response.end("Not found");
+          }
+        });
+      }
+    }
+  ],
+  server: {
+    host: "127.0.0.1",
+    port: 4317
+  }
+});

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@robotaccomplice/architext",
+  "version": "1.0.0",
+  "description": "Local JSON-backed architecture and dataflow viewer for engineering teams and LLM-maintained architecture maps.",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "architext": "tools/architext-adopt.mjs"
+  },
+  "files": [
+    "docs/architecture",
+    "docs/assets/screenshots",
+    "docs/architext/data",
+    "docs/architext/dist",
+    "docs/architext/index.html",
+    "docs/architext/AGENTS_APPENDIX.md",
+    "docs/architext/LLM_ARCHITEXT.md",
+    "docs/architext/package.json",
+    "docs/architext/package-lock.json",
+    "docs/architext/public",
+    "docs/architext/README.md",
+    "docs/architext/schema",
+    "docs/architext/src",
+    "docs/architext/tools",
+    "docs/architext/tsconfig.json",
+    "docs/architext/vite.config.ts",
+    "tools",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "architext": "node tools/architext-adopt.mjs serve .",
+    "architext:build": "node tools/architext-adopt.mjs build .",
+    "architext:clean": "node tools/architext-adopt.mjs clean .",
+    "architext:doctor": "node tools/architext-adopt.mjs doctor .",
+    "architext:prompt": "node tools/architext-adopt.mjs prompt .",
+    "architext:validate": "node tools/architext-adopt.mjs validate .",
+    "build": "npm --prefix docs/architext run build",
+    "cli": "node tools/architext-adopt.mjs",
+    "doctor": "node tools/architext-adopt.mjs doctor --target .",
+    "prepack": "npm run build",
+    "test": "node --test",
+    "validate": "node docs/architext/tools/validate-architext.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.4",
+    "@types/react": "^19.0.2",
+    "@types/react-dom": "^19.0.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.7"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/robot-accomplice/architext.git"
+  },
+  "keywords": [
+    "architecture",
+    "c4",
+    "dataflow",
+    "documentation",
+    "llm",
+    "schema"
+  ],
+  "author": "Robot Accomplice",
+  "bugs": {
+    "url": "https://github.com/robot-accomplice/architext/issues"
+  },
+  "homepage": "https://github.com/robot-accomplice/architext#readme"
+}