@nebularstreams/statify 3.0.0

package/templates/landing/metadata.json

@@ -0,0 +1,115 @@
+{
+  "title": "Brightfield Labs",
+  "description": "Thoughtful digital products for growing organizations",
+  "canonical": "https://example.com",
+  "image": {
+    "url": "https://example.com/res/nebular.color.png",
+    "alt": "Brightfield Labs"
+  },
+  "ogtype": "website",
+  "site": {
+    "name": "Brightfield Labs",
+    "url": "https://example.com",
+    "domain": "example.com",
+    "cookies": "none",
+    "nocookies": false,
+    "simplepages": true
+  },
+  "author": {
+    "@type": "Organization",
+    "name": "Brightfield Labs",
+    "url": "https://example.com",
+    "logo": "https://example.com/res/logos/logo.white.png"
+  },
+  "publisher": {
+    "@type": "Organization",
+    "name": "Brightfield Labs",
+    "url": "https://example.com",
+    "logo": "https://example.com/res/logos/logo.white.png"
+  },
+  "head": [
+    {
+      "t": "link",
+      "rel": "icon",
+      "type": "image/png",
+      "href": "res/logos/favicon.png"
+    },
+    {
+      "t": "link",
+      "rel": "stylesheet",
+      "href": "app/website.css"
+    },
+    {
+      "t": "link",
+      "rel": "stylesheet",
+      "href": "res/custom.css"
+    },
+    {
+      "t": "link",
+      "rel": "apple-touch-icon",
+      "href": "res/logos/favicon.png"
+    },
+    {
+      "t": "script",
+      "src": "app/website.min.js"
+    }
+  ],
+  "meta": [
+    {
+      "charSet": "utf-8"
+    },
+    {
+      "name": "robots",
+      "content": "all"
+    },
+    {
+      "lang": "en"
+    },
+    {
+      "name": "viewport",
+      "content": "width=device-width, maximum-scale=5, user-scalable=yes, initial-scale=1"
+    },
+    {
+      "name": "theme-color",
+      "content": "#111827"
+    },
+    {
+      "name": "mobile-web-app-capable",
+      "content": "yes"
+    },
+    {
+      "name": "apple-mobile-web-app-capable",
+      "content": "yes"
+    },
+    {
+      "name": "apple-mobile-web-app-status-bar-style",
+      "content": "black"
+    }
+  ],
+  "navibar": {
+    "home": "/",
+    "logo": "res/nebular.medallion.transparent.png",
+    "displayTitle": true,
+    "autoHide": true,
+    "links": {
+      "SPACER": {
+        "separator": true
+      },
+      "Documentation": {
+        "url": "/docs/index",
+        "icon": "book"
+      },
+      "Contact": {
+        "url": "mailto:hello@example.com",
+        "icon": "envelope"
+      }
+    }
+  },
+  "links.doc": {
+    "documents": {
+      "static": true,
+      "class": "inter"
+    }
+  },
+  "links.metadata": {}
+}

package/templates/landing/pages/index.json

@@ -0,0 +1,268 @@
+{
+  "widget": "FeatureList",
+  "title": "Brightfield Labs",
+  "titleRaw": true,
+  "notitlebar": true,
+  "canonical": "https://example.com",
+  "class": "notoolbar",
+  "features": {
+    "mainClass": "text-al-left col-md-10 offset-md-1 col-xl-8 offset-xl-2 col-xxl-6 offset-xxl-3",
+    "containerClass": "pad-0",
+    "itemsClass": "pad-1",
+    "title": {
+      "containerClass": "fullrow back-one",
+      "class": "newbox",
+      "items": [
+        {
+          "image": "res/logos/logo.white.png",
+          "class": "col-6 mainlogo",
+          "imageClass": "w-100",
+          "alt": "Brightfield Labs logo placeholder",
+          "el": "div"
+        },
+        {
+          "el": "h1",
+          "text": "Thoughtful digital products<br>for growing organizations",
+          "class": "motto"
+        }
+      ]
+    },
+    "cards": [
+      {
+        "title": "About Brightfield Labs",
+        "containerClass": "bigpad back-zero",
+        "class": "flexrow wrap",
+        "items": [
+          {
+            "el": "h2",
+            "text": "From promising idea to dependable product",
+            "class": "accent"
+          },
+          {
+            "el": "div",
+            "class": "flexbreak"
+          },
+          {
+            "class": "col-12 col-md-offset-1 col-md-10",
+            "text": "Brightfield Labs is a fictional product studio used to demonstrate this Statify landing-page template. We help organizations clarify ideas, design useful experiences, and build software that is ready for everyday work."
+          },
+          {
+            "bootstrapClass": "col-lg-4 col-xxl-4",
+            "cardsClass": "pad-2",
+            "cards": [
+              {
+                "icon": "compass",
+                "iconClass": "icon-outline",
+                "subclass": "text-al-center pad-4",
+                "title": "Product Strategy",
+                "text": "Turn an open-ended challenge into a focused roadmap, clear priorities, and practical measures of success."
+              },
+              {
+                "icon": "pencil-ruler",
+                "iconClass": "icon-outline",
+                "subclass": "text-al-center pad-4",
+                "title": "Experience Design",
+                "text": "Shape accessible interfaces and workflows around the people who will use them every day."
+              },
+              {
+                "icon": "code",
+                "iconClass": "icon-outline",
+                "subclass": "text-al-center pad-4",
+                "title": "Engineering",
+                "text": "Build maintainable applications and services with a strong foundation for security, performance, and growth."
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "title": "Selected Work",
+        "containerClass": "pad-0 back-one",
+        "class": "flexrow wrap",
+        "items": [
+          {
+            "el": "h2",
+            "text": "Selected Work",
+            "class": "w-100 accent heading text-al-center"
+          }
+        ]
+      },
+      {
+        "title": "Atlas Operations",
+        "containerClass": "pad-0 back-one",
+        "class": "flexrow wrap nearbox",
+        "items": [
+          {
+            "el": "h2",
+            "text": "Atlas Operations",
+            "class": "project-heading col-12"
+          },
+          {
+            "el": "h3",
+            "text": "A shared workspace for fast-moving teams",
+            "class": "accent col-12"
+          },
+          {
+            "class": "project-description",
+            "text": "Atlas brings planning, live status, and operational knowledge into one adaptable workspace. Teams can configure their own views while working from the same source of truth."
+          },
+          {
+            "imageCarousel": [
+              {"url": "res/carousel/image-1.webp"},
+              {"url": "res/carousel/image-2.webp"},
+              {"url": "res/carousel/image-3.webp"}
+            ],
+            "alt": "Atlas Operations interface examples",
+            "class": "col-12 asp169 marg-v marg-4",
+            "imageClass": "framed w-100 fadein"
+          },
+          {
+            "bootstrapClass": "col-lg-4 col-xxl-4",
+            "cardsClass": "pad-2",
+            "cards": [
+              {
+                "icon": "layer-group",
+                "iconClass": "icon-outline",
+                "subclass": "text-al-center pad-4",
+                "title": "Flexible Workspaces",
+                "text": "Reusable modules let each team organize information around its own responsibilities."
+              },
+              {
+                "icon": "bolt",
+                "iconClass": "icon-outline",
+                "subclass": "text-al-center pad-4",
+                "title": "Live Updates",
+                "text": "Changes appear as work happens, keeping decisions and status visible across the organization."
+              },
+              {
+                "icon": "shield-alt",
+                "iconClass": "icon-outline",
+                "subclass": "text-al-center pad-4",
+                "title": "Built for Trust",
+                "text": "Clear permissions, reliable history, and resilient infrastructure support critical workflows."
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "title": "Fieldnote",
+        "containerClass": "pad-0 back-one",
+        "class": "flexrow wrap nearbox",
+        "items": [
+          {
+            "el": "h2",
+            "text": "Fieldnote",
+            "class": "project-heading col-12"
+          },
+          {
+            "el": "h3",
+            "text": "Simple reporting for teams away from the desk",
+            "class": "accent col-12"
+          },
+          {
+            "class": "project-description",
+            "text": "Fieldnote helps distributed teams capture observations, photos, and follow-up actions on any device. A streamlined review flow turns field reports into useful decisions."
+          },
+          {
+            "image": "res/proj/proj-fieldnote.webp",
+            "alt": "Fieldnote product interface placeholder"
+          }
+        ]
+      },
+      {
+        "title": "Common Ground",
+        "containerClass": "pad-0 back-one",
+        "class": "flexrow wrap nearbox",
+        "items": [
+          {
+            "el": "h2",
+            "text": "Common Ground",
+            "class": "project-heading col-12"
+          },
+          {
+            "class": "project-description",
+            "text": "Common Ground is a prototype for shared digital spaces where remote groups can meet, explore ideas, and work together in a more natural setting."
+          },
+          {
+            "image": "res/proj/proj-common-ground.webp",
+            "alt": "Common Ground collaborative environment placeholder"
+          }
+        ]
+      },
+      {
+        "title": "Experiments",
+        "containerClass": "pad-0 back-two",
+        "class": "flexrow wrap nearbox",
+        "items": [
+          {
+            "el": "h2",
+            "text": "Experiments",
+            "class": "col-12"
+          },
+          {
+            "class": "project-description",
+            "text": "Small experiments keep our practice curious. These placeholders show how a Statify page can mix a short introduction with a flexible image gallery."
+          },
+          {
+            "image": "res/proj/banda-tech-client.webp",
+            "alt": "Mobile product experiment placeholder"
+          },
+          {
+            "image": "res/proj/banda-tech-server.webp",
+            "alt": "Creative tool experiment placeholder"
+          }
+        ]
+      },
+      {
+        "title": "Work With Us",
+        "containerClass": "bigpad back-zero",
+        "class": "flexrow wrap nearbox",
+        "items": [
+          {
+            "el": "h2",
+            "text": "Have something useful to build?",
+            "class": "accent col-12"
+          },
+          {
+            "class": "project-description",
+            "text": "Tell us what you are trying to improve, who it is for, and where the idea stands today. We will help you find a practical next step."
+          },
+          {
+            "link": {
+              "href": "mailto:hello@example.com",
+              "text": "hello@example.com",
+              "class": "accent w-100"
+            }
+          }
+        ]
+      }
+    ]
+  },
+  "footer": {
+    "title": "Brightfield Labs",
+    "copyright": "Brightfield Labs &copy; 2026",
+    "items": [],
+    "links": [
+      {
+        "title": "Contact",
+        "href": "mailto:hello@example.com"
+      },
+      {
+        "title": "Cookies",
+        "href": "/docs/cookies",
+        "target": "doc"
+      },
+      {
+        "title": "Privacy",
+        "href": "/docs/privacy",
+        "target": "doc"
+      },
+      {
+        "title": "Terms",
+        "href": "/docs/tos",
+        "target": "doc"
+      }
+    ]
+  }
+}

package/tool/cli.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const publish = require("../src/publisher-lib");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const COMMANDS = new Set(["init", "app", "list", "folder", "file"]);
+
+function fail(message, code = 1) {
+	const error = new Error(message);
+	error.exitCode = code;
+	throw error;
+}
+
+function usage() {
+	return `Usage:
+  statify init <destination> <template>
+  statify folder <source> [destination]
+  statify file <file> [destination] <source>
+  statify list <list-file> <source> [destination] [filter-id]
+  statify app [simple|software|worlds]`;
+}
+
+function existingDirectory(value, label) {
+	const result = path.resolve(value);
+	if (!fs.existsSync(result) || !fs.statSync(result).isDirectory()) {
+		fail(`${label} does not exist or is not a directory: ${value}`);
+	}
+	return result;
+}
+
+function availableTemplates() {
+	return fs.readdirSync(path.join(PACKAGE_ROOT, "templates"), { withFileTypes: true })
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name)
+		.sort();
+}
+
+function init(destinationArg, templateName) {
+	if (!destinationArg || !templateName) {
+		fail(`Usage: statify init <destination> <template>\nAvailable templates: ${availableTemplates().join(", ")}`);
+	}
+
+	const destination = path.resolve(destinationArg);
+	const template = path.join(PACKAGE_ROOT, "templates", templateName);
+	if (fs.existsSync(destination)) fail(`Destination already exists: ${destinationArg}`);
+	if (!fs.existsSync(template) || !fs.statSync(template).isDirectory()) {
+		fail(`Unknown template: ${templateName}\nAvailable templates: ${availableTemplates().join(", ")}`);
+	}
+
+	fs.cpSync(template, destination, { recursive: true, errorOnExist: true });
+	console.log(`Initialized ${templateName} template in ${destination}`);
+}
+
+async function publishFile(filename, destination, source) {
+	const html = await publish(`./${filename.split(path.sep).join("/")}`, source);
+	const relativeOutput = filename.slice(0, -path.extname(filename).length) + ".html";
+	const output = path.join(destination, relativeOutput);
+	fs.mkdirSync(path.dirname(output), { recursive: true });
+	fs.writeFileSync(output, html, "utf8");
+	return output;
+}
+
+async function file(fileArg, destinationArg, sourceArg) {
+	if (fileArg && destinationArg && !sourceArg) {
+		sourceArg = destinationArg;
+		destinationArg = undefined;
+	}
+	if (!fileArg || !sourceArg) fail("Usage: statify file <file> [destination] <source>");
+
+	const source = existingDirectory(sourceArg, "Source");
+	const pages = path.join(source, "pages");
+	const absoluteFile = path.resolve(fileArg);
+	const filename = path.relative(pages, absoluteFile);
+	if (filename.startsWith("..") || path.isAbsolute(filename)) {
+		fail(`File must be inside ${pages}: ${fileArg}`);
+	}
+	if (!fs.existsSync(absoluteFile) || !fs.statSync(absoluteFile).isFile()) {
+		fail(`File does not exist: ${fileArg}`);
+	}
+	if (![".json", ".md"].includes(path.extname(absoluteFile).toLowerCase())) {
+		fail(`Page must be a .json or .md file: ${fileArg}`);
+	}
+
+	const destination = path.resolve(destinationArg || "out");
+	const output = await publishFile(filename, destination, source);
+	console.log(`Generated ${output}`);
+}
+
+function walk(directory, relative = "") {
+	return fs.readdirSync(directory, { withFileTypes: true })
+		.filter((entry) => !entry.name.startsWith("."))
+		.flatMap((entry) => {
+			const item = path.join(relative, entry.name);
+			return entry.isDirectory() ? walk(directory, item) : [item];
+		});
+}
+
+async function folder(sourceArg, destinationArg) {
+	if (!sourceArg) fail("Usage: statify folder <source> [destination]");
+
+	const source = existingDirectory(sourceArg, "Source");
+	const pages = existingDirectory(path.join(source, "pages"), "Pages directory");
+	const destination = path.resolve(destinationArg || "out");
+	fs.mkdirSync(destination, { recursive: true });
+
+	for (const filename of walk(pages)) {
+		const extension = path.extname(filename).toLowerCase();
+		if (extension === ".json" || extension === ".md") {
+			console.log(`Converting ${filename}`);
+			await publishFile(filename, destination, source);
+		} else {
+			console.log(`Copying ${filename}`);
+			const output = path.join(destination, filename);
+			fs.mkdirSync(path.dirname(output), { recursive: true });
+			fs.copyFileSync(path.join(pages, filename), output);
+		}
+	}
+
+	const assets = path.join(source, "assets");
+	if (fs.existsSync(assets) && fs.statSync(assets).isDirectory()) {
+		fs.cpSync(assets, destination, { recursive: true });
+	}
+	console.log(`Output written to ${destination}`);
+}
+
+function runNode(script, args, cwd = process.cwd()) {
+	const result = spawnSync(process.execPath, [script, ...args], { cwd, stdio: "inherit" });
+	if (result.error) fail(result.error.message);
+	if (result.status !== 0) fail(`Command failed with exit code ${result.status}`, result.status || 1);
+}
+
+function list(listFile, sourceArg, destinationArg, filterId) {
+	if (!listFile || !sourceArg) {
+		fail("Usage: statify list <list-file> <source> [destination] [filter-id]");
+	}
+
+	const source = existingDirectory(sourceArg, "Source");
+	const destination = path.resolve(destinationArg || "out");
+	fs.mkdirSync(destination, { recursive: true });
+	const args = [listFile, source, destination];
+	if (filterId) args.push(filterId);
+	return runNode(path.join(PACKAGE_ROOT, "src", "publisher-list.js"), args, path.join(source, "lists"));
+}
+
+function app(application = "simple") {
+	if (!new Set(["simple", "software", "worlds"]).has(application)) {
+		fail(`Unknown application: ${application}. Expected simple, software, or worlds.`);
+	}
+
+	const websiteRoot = path.join(PACKAGE_ROOT, "src.website");
+	const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+	const result = spawnSync(npm, ["run", `build:${application}`], {
+		cwd: websiteRoot,
+		stdio: "inherit"
+	});
+	if (result.error) fail(result.error.message);
+	if (result.status !== 0) fail(`Application build failed with exit code ${result.status}`, result.status || 1);
+}
+
+function invocation(argv) {
+	if (COMMANDS.has(argv[0])) return [argv[0], argv.slice(1)];
+	fail(`Unknown command: ${argv[0]}\n\n${usage()}`);
+}
+
+async function main(argv) {
+	if (argv.includes("--help") || argv.includes("-h") || argv.length === 0) {
+		console.log(usage());
+		return;
+	}
+
+	const [command, args] = invocation(argv);
+	await { init, folder, file, list, app }[command](...args);
+}
+
+main(process.argv.slice(2)).catch((error) => {
+	console.error(`statify: ${error.message}`);
+	process.exitCode = error.exitCode || 1;
+});