@wenathlan/cobaia 0.0.0-stage → 2.0.158

package/capacitor.config.ts

@@ -0,0 +1,51 @@
+/**
+ * the one conversion config of the app, living at the app root so the
+ * capacitor cli resolves it from its working directory: the mobile lane runs
+ * `npx cap add`/`npx cap sync` from the app root and every path below — webDir
+ * above all — resolves relative to that cwd.
+ *
+ * the theme build (hashed bundles emitted by vite straight into the app root,
+ * publish = ".") is the single application
+ * source of every platform: the browser, github pages, vercel, netlify, the tv
+ * and the android wrapper all render the same web bundle. the native shells
+ * stay runner-side toolchain output (generated on the mobile workflow into
+ * android/ and ios/, never committed).
+ *
+ * the shape follows the capacitor-cli config contract; the type import stays
+ * out so the web typecheck never requires the optional capacitor toolchain.
+ */
+
+/** the structural contract of the capacitor config the cli reads (the subset this repository declares). */
+type CapacitorConfigShape = {
+  appId: string;
+  appName: string;
+  webDir: string;
+  bundledWebRuntime?: boolean;
+  server?: { androidScheme?: string };
+  android?: { allowMixedContent?: boolean; path?: string };
+  ios?: { path?: string };
+};
+
+const config: CapacitorConfigShape = {
+  /** the cobaia mobile identity — the id the mobile lane stamps onto the generated shells. */
+  appId: "im.cobaia.app",
+  appName: "Cobaia",
+  /** the vite build of the theme: pnpm build emits the hashed bundles at the app root. */
+  webDir: ".",
+  bundledWebRuntime: false,
+  server: {
+    androidScheme: "https",
+  },
+  /** the build paths the mobile lane answers: the android wrapper and the ios
+   * shell materialize beside this config (family-mobile.yml) and the cli
+   * reads them from these declared folders. */
+  android: {
+    allowMixedContent: false,
+    path: "android",
+  },
+  ios: {
+    path: "ios",
+  },
+};
+
+export default config;

package/checkoutlinks.ts

@@ -0,0 +1,80 @@
+/**
+ * checkoutlinks.ts — the typed accessor of the billing configuration of
+ * the family site: the thin door the pricing page, the support page and
+ * the intro plans zone import, answering the plan table and the support
+ * channels of the content lane (content.ts — the manifest; db.ts — the
+ * content_rows table; the platform gateway — GET /api/v1/ui/content). The
+ * data never lives here anymore: checkoutlinks() and supportlinks() answer
+ * the live rows the platform served, the manifest seed otherwise (the
+ * uistore chain). The payment links themselves are configuration, never
+ * code: the owner pins the checkout hrefs (Stripe Payment Links or Paddle
+ * overlays) into the store once billing goes live. Until then every href
+ * ships empty and the interface renders the honest empty state — "checkout
+ * not configured yet" — instead of pretending.
+ *
+ * The words never ride here: every plan sentence (name, billing period,
+ * blurb, features) answers from the label store (labels.ts — the manifest
+ * the seed carries into the site database), so the pricing cards and the
+ * intro plans zone read their prose through the typed accessor and this
+ * lane keeps only the billing values — ids, prices and links.
+ *
+ * No network call ever happens here: the links are plain hrefs the visitor
+ * chooses to follow, no key is committed (not even a placeholder that looks
+ * real) and no script is loaded. The prices are placeholders (US$0 / 5 / 19
+ * per month) until the billing platform decision lands.
+ */
+
+import {
+  type checkoutplan,
+  contenttable,
+  contentvalue,
+  seedPlans,
+  seedSupportLinks,
+  type supportlinks as supportlinkstable,
+} from "./content.ts";
+
+export type { checkoutplan, supportlinkstable as supportlinks };
+
+/**
+ * The typed accessor of the pricing table: the live db rows when the
+ * platform answered, the manifest seed otherwise — in display order (the
+ * prose answers from the label store; only the billing values ride this
+ * lane).
+ *
+ * @returns the plans of the /pricing page.
+ */
+export function checkoutlinks(): readonly checkoutplan[] {
+  return contenttable("plans", seedPlans);
+}
+
+/**
+ * The typed accessor of the support channels: the live db row when the
+ * platform answered, the manifest seed otherwise — the same rule as the
+ * plans: hrefs stay empty until the owner configures them.
+ *
+ * @returns the support channels of the /support page.
+ */
+export function supportlinks(): Readonly<supportlinkstable> {
+  return contentvalue("supportlinks", seedSupportLinks);
+}
+
+/**
+ * Answers whether a configured link is live. An empty (or whitespace) href
+ * means the feature is not configured yet and the interface must say so.
+ *
+ * @param href the configured link href.
+ * @returns true only when the href carries a real target.
+ */
+export function isconfigured(href: string): boolean {
+  return href.trim().length > 0;
+}
+
+/**
+ * Finds one plan of the table by its stable id.
+ *
+ * @param id the plan id (free, pro, studio).
+ * @returns the plan, or undefined when no plan carries the id.
+ */
+export function planbyid(id: string): checkoutplan | undefined {
+  return checkoutlinks().find((plan) => plan.id === id);
+}

package/cli.ts

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * @file cli.ts — the cobaia binary seat of the clibin wave (PR13 — CLI
+ *   binário mesmo design): the same Windows 11 chat console as the web and
+ *   desktop surfaces, rendered inside the terminal as a subapp — the only
+ *   difference is responsiveness / DPI (the 28px top rule becomes one line
+ *   and the accent falls back to the ANSI 256 palette).
+ * @module cobaia/cli
+ * @family wave/clibin
+ * @law same design as web / desktop, difference only responsiveness / DPI
+ * @seat 2026 · rung 2.0.157 · hierarchical JSDoc, tokens/flags, no hardcoded
+ *   data — the version is read from package.json at runtime and the engine
+ *   one-liner is quoted from the app docs.
+ * @runtime node strips the types; the shebang hands the file to the runtime
+ *   (the saddle law).
+ * @deps zero — node builtins only (readline/promises, process, fs/promises).
+ */
+
+import { createInterface } from "node:readline/promises";
+import { argv, exit, stdin, stdout } from "node:process";
+import { readFile } from "node:fs/promises";
+
+/* ════════════════════════════════════════════════════════════════════ */
+/* Section 1: the chrome tokens — the windows 11 palette folded to the DPI of the terminal (the accent #a3d7e6 lands on ansi 117, the focus #4cc2ff on 75, the hover red rgb(232,17,35) on 203; the 28px top rule becomes one line). */
+/* ════════════════════════════════════════════════════════════════════ */
+
+/** the chat accent of the prompt and the titlebar name. */
+const ACCENT = "\x1b[38;5;117m" as const; // #a3d7e6
+/** the focus ink of the active top rule. */
+const FOCUS = "\x1b[38;5;75m" as const; // #4cc2ff
+/** the hover red of the unknown-command rows. */
+const HOVER = "\x1b[38;5;203m" as const; // rgb(232, 17, 35)
+/** the dim ink of the description rows (the minimal text law). */
+const INK = "\x1b[2m" as const;
+/** the reset token that closes every colored run. */
+const RESET = "\x1b[0m" as const;
+/** the single glyph of the rules and the rails. */
+const BAR = "─" as const;
+
+/** the app name of this binary seat — the titlebar text. */
+const APP = "cobaia" as const;
+/** the engine ownership one-liner, quoted from the app docs. */
+const ENGINE =
+  "owns no engine file — the content site is the monetization surface: static plans, support rails and honest ad slots, no backend no tracking (docs/features.md)" as const;
+
+/** the titlebar bar: the app name on the left rail, the window controls on the right — the windows 11 chrome inside the terminal. */
+function titlebar(): string {
+  return `${ACCENT}┌ ${APP} ─ cli${RESET}  ${INK}${BAR.repeat(24)} ─ ❐ ✕${RESET}`;
+}
+
+/** the top rule: the 28px divider of the web surface folded to one terminal line. */
+function toprule(): string {
+  return `${FOCUS}${BAR.repeat(3)} ${APP} ${BAR.repeat(3)}${RESET}`;
+}
+
+/* ════════════════════════════════════════════════════════════════════ */
+/* Section 2: the runtime reads — no hardcoded data; the version comes from package.json at runtime. */
+/* ════════════════════════════════════════════════════════════════════ */
+
+/** reads the version of this seat from the sibling package.json — never a literal. */
+async function readversion(): Promise<string> {
+  try {
+    const manifest = JSON.parse(await readFile(new URL("./package.json", import.meta.url), "utf8")) as { version?: string };
+    return manifest.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+/* ════════════════════════════════════════════════════════════════════ */
+/* Section 3: the chat console — the REPL with the ❯ prompt, the command dispatch and the same chat look as the web surface. */
+/* ════════════════════════════════════════════════════════════════════ */
+
+/** the command help of the console — minimal text law: title + description only. */
+function help(): string[] {
+  return [
+    `${INK}commands${RESET}`,
+    `  help      ${INK}this list${RESET}`,
+    `  version   ${INK}the package version, read from package.json at runtime${RESET}`,
+    `  engine    ${INK}the engine ownership one-liner of the app${RESET}`,
+    `  exit      ${INK}close the console${RESET}`,
+  ];
+}
+
+/** runs the chat console: the titlebar, the top rule, the ❯ prompt and the dispatch (help, version, engine, exit); an eof on stdin closes the console the same way exit does. */
+export async function main(): Promise<void> {
+  /* the version read happens before the interface exists, so a piped stdin never races the readline open (node buffers the pipe until the reader resumes it). */
+  const version = await readversion();
+  const rl = createInterface({ input: stdin, output: stdout });
+  let eof = false;
+  rl.on("close", () => { eof = true; });
+  console.log(titlebar());
+  console.log(toprule());
+  console.log(`${ACCENT}${APP}${RESET} ${INK}v${version}${RESET}`);
+  console.log(`${INK}the ${APP} console — same design as web / desktop, only the DPI differs. type help.${RESET}`);
+  rl.setPrompt(`${ACCENT}❯${RESET} `);
+  rl.prompt();
+  for await (const raw of rl) {
+    const line = raw.trim();
+    const command = line.length > 0 ? line.split(/\s+/)[0]!.toLowerCase() : "";
+    if (command === "exit") rl.close();
+    else if (command === "help") for (const row of help()) console.log(row);
+    else if (command === "version") console.log(`${ACCENT}${APP}${RESET} ${version}`);
+    else if (command === "engine") console.log(`${INK}${ENGINE}${RESET}`);
+    else if (command.length > 0) console.log(`${HOVER}✕${RESET} ${INK}unknown command: ${command} — type help${RESET}`);
+    if (command === "exit") break;
+    /* the prompt is cosmetic chrome: a piped stdin that already reached eof skips it, the buffered lines still answer. */
+    if (!eof) rl.prompt();
+  }
+  console.log(`${INK}${APP} console closed.${RESET}`);
+}
+
+/* the autorun guard (the saddle law): only a direct `node cli.ts` (or a bun run) boots the console here — an import stays quiet. */
+if (import.meta.url === `file://${argv[1]}`) main().catch((error) => { console.error(error); exit(1); });

package/cobaia.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+    <AssemblyName>cobaia</AssemblyName>
+    <RootNamespace>cobaia</RootNamespace>
+    <PackageId>cobaia</PackageId>
+    <Version>2.0.158</Version>
+    <Authors>wenathlan</Authors>
+    <Description>Distribution package containing the cobaia documentation set and the tests directory. cobaia is the monetization surface — the plans, the support rails and the honest advertisement slots.</Description>
+    <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
+    <PackageProjectUrl>https://github.com/wenathlan/devthink</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/wenathlan/devthink</RepositoryUrl>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+  </PropertyGroup>
+  <ItemGroup>
+    <None Include="README.md" Pack="true" PackagePath="/" />
+    <None Include="docs/**/*" Pack="true" PackagePath="contentFiles/any/any/docs/" />
+    <None Include="tests/**/*" Pack="true" PackagePath="contentFiles/any/any/tests/" />
+  </ItemGroup>
+</Project>

package/cobaia.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |spec|
+  spec.name = "cobaia"
+  spec.version = ENV.fetch("COBAIA_VERSION", "2.0.158")
+  spec.authors = ["wenathlan"]
+  spec.email = ["support@users.noreply.github.com"]
+  spec.summary = "The cobaia documentation and tests envelope (the monetization surface — the plans, the support rails and the honest advertisement slots)."
+  spec.description = "Distributes the cobaia documentation set and the tests directory as one Ruby gem. cobaia is the monetization surface — the plans, the support rails and the honest advertisement slots."
+  spec.homepage = "https://github.com/wenathlan/devthink"
+  spec.license = "GPL-3.0-only"
+  spec.required_ruby_version = ">= 3.1"
+  spec.files = Dir["README.md", "docs/**/*", "tests/**/*"]
+  spec.metadata["source_code_uri"] = "https://github.com/wenathlan/devthink"
+  spec.metadata["homepage_uri"] = spec.homepage
+end

package/cobaia.java

@@ -0,0 +1,16 @@
+package io.github.wenathlan.cobaia;
+
+/**
+ * The cobaia version envelope carrier.
+ *
+ * <p>The carrier answers the lowercase file name doctrine (the technical name {@code cobaia}
+ * while the class keeps the presentation name {@code Cobaia}); the class drops the public
+ * modifier so the java file name rule holds — the envelope carries the version constant the
+ * metadata lockstep stamps, the registry lanes never compile it.
+ */
+final class Cobaia {
+  /** The version of the cobaia envelope (the six-distribution completeness wave). */
+  public static final String VERSION = "2.0.158";
+  private Cobaia() {
+  }
+}