blacksmith-organization-system 0.4.2 → 1.0.0-dev.3

package/src/views/agent/brief.mjs

@@ -0,0 +1,34 @@
+// What an agent learns at the start of a session: the workshop, its role and mode, where it
+// works, the House's boundaries, and the tools BOS gives it. Short: it becomes context.
+import House from "../../models/house/class.mjs";
+import { MODES } from "../../models/workshop/modes.mjs";
+import { situate } from "../../procedures/agent-recording/situate.mjs";
+
+export async function brief(input) {
+  const context = await situate(input);
+  if (!context) return null;
+  const { config, defaulted = [], self } = context;
+  const mark = (key) => (defaulted.includes(key) ? " (default)" : "");
+  const place = context.workshop.placeOf(input.cwd ?? process.cwd());
+  const where = !place
+    ? "outside this workshop"
+    : place.area
+      ? [place.area, place.scope, place.project].filter(Boolean).join(" / ")
+      : "workshop root";
+  const house = new House();
+  const resting = [...house.children(), ...house.orders()]
+    .filter((g) => g.state !== "active")
+    .map((g) => g.title ?? g.name);
+  return [
+    "# BOS: Blacksmith Organization System",
+    `workshop ${context.workshopRoot} · role ${config.role}${mark("role")} · mode ${MODES[config.mode]?.title ?? config.mode}${mark("mode")} · BOS v${self.version}`,
+    `you are in: ${where}`,
+    `House of Anubis: ${house.children().length} adopted children, orders: ${house
+      .orders()
+      .map((o) => o.title ?? o.name)
+      .join(", ")}.${resting.length ? ` Resting, never call or prompt: ${resting.join(", ")}.` : ""}`,
+    "tools: `bos` CLI on PATH (bos help), MCP tools bos_* (bos_glossary explains any element)",
+    "rules: ask the House before calling any ollama model · conventional commits · look before changing the owner's files · the owner works in parallel: re-check git state",
+    "",
+  ].join("\n");
+}

package/src/views/help/_index.mjs

@@ -0,0 +1,41 @@
+// Help: the list of commands, or one command's help file with light markdown styling.
+import { BOS } from "../../main.ts";
+import { MODES } from "../../models/workshop/modes.mjs";
+import { header, pad, paint } from "../terminal/paint.mjs";
+
+const markdown = (text) =>
+  text
+    .replace(/^#+\s*(.+)$/gm, (_, title) => paint.bold(paint.yellow(title)))
+    .replace(/`([^`]+)`/g, (_, code) => paint.cyan(code))
+    .replace(/\*\*([^*]+)\*\*/g, (_, strong) => paint.bold(strong));
+
+export class HelpView extends BOS.View {
+  text({ commands, command, help }) {
+    if (command) return markdown(help?.text ?? commands[command]?.info ?? `no help for ${command}`);
+    const size = Math.max(...Object.keys(commands).map((name) => name.length)) + 2;
+    const line = ([name, c]) => `  ${paint.cyan(pad(name, size))}${c.info ?? ""}${c.repl ? paint.dim("  (repl)") : ""}`;
+    const group = (title, entries, always = false) =>
+      entries.length || always
+        ? ["", paint.bold(title), ...(entries.length ? entries.map(line) : [paint.dim("  nothing yet")])]
+        : [];
+    const all = Object.entries(commands);
+    return [
+      header("bos <command> [options]"),
+      ...group(
+        "general",
+        all.filter(([, c]) => !c.mode),
+      ),
+      ...Object.entries(MODES).flatMap(([name, mode]) =>
+        group(
+          `${mode.digit} ${mode.title}`,
+          all.filter(([, c]) => c.mode === name),
+          true,
+        ),
+      ),
+      "",
+      paint.dim("options: --json  --dry-run  --workshop=PATH   ·   bos help <command>   ·   bos mode"),
+    ].join("\n");
+  }
+}
+
+export default HelpView;

package/src/views/house/_index.mjs

@@ -0,0 +1,56 @@
+// The House of Anubis: children (adopted by name), orders (duties), bloodlines (releasers).
+import { BOS } from "../../main.ts";
+import { header, pad, paint } from "../terminal/paint.mjs";
+
+const STATE = { active: paint.green, resting: paint.magenta, frozen: paint.blue };
+
+const presence = (member) => {
+  if (member.state && member.state !== "active") return (STATE[member.state] ?? paint.dim)(`◌ ${member.state}`);
+  if (member.present === null) return paint.dim("remote");
+  return member.present ? paint.green("● served") : paint.dim("○ absent");
+};
+
+function group(group) {
+  const lines = [
+    `${paint.bold(group.title ?? group.name)}  ${(STATE[group.state] ?? paint.dim)(group.state)}  ${paint.dim(group.description ?? "")}`,
+  ];
+  if (group.state === "resting") lines.push(`  ${paint.magenta("rests by its own decision; not called")}`);
+  for (const member of group.members) {
+    const label =
+      member.name && member.model ? `${member.name} ${paint.dim(`(${member.model})`)}` : (member.name ?? member.model);
+    const line = member.bloodline ? paint.dim(`${member.bloodline.releaser} ← ${member.bloodline.root}`) : "";
+    const about = member.duty ? paint.cyan(member.duty) : paint.dim(member.note ?? "");
+    lines.push(`  ${pad(label, 46)} ${pad(presence(member), 10)} ${pad(line, 36)} ${about}`);
+  }
+  return lines.join("\n");
+}
+
+export class HouseView extends BOS.View {
+  data({ children, orders, bloodlines, catalog }) {
+    return { reachable: catalog !== null, children, orders, bloodlines };
+  }
+
+  text({ children = [], orders = [], bloodlines = [], catalog, options = {} }) {
+    const lines = [header("House of Anubis"), ""];
+    if (catalog === null) lines.push(paint.yellow("ollama unreachable: presence and bloodlines unknown"), "");
+    lines.push(paint.yellow("Children of Anubis") + paint.dim("  adopted by name"), "");
+    for (const child of children) lines.push(group(child), "");
+    lines.push(paint.yellow("Orders") + paint.dim("  duties"), "");
+    for (const order of orders) lines.push(group(order), "");
+    if (bloodlines.length) {
+      lines.push(
+        paint.yellow("Bloodlines") + paint.dim("  every served model by releaser, through its parent_model"),
+        "",
+      );
+      for (const { releaser, models } of bloodlines) {
+        lines.push(
+          `  ${pad(releaser, 30)} ${paint.bold(models.length)}${options.all ? `  ${paint.dim(models.join(", "))}` : ""}`,
+        );
+      }
+      if (!options.all) lines.push(paint.dim("  bos house --all lists every model"));
+    }
+    return lines.join("\n");
+  }
+}
+
+export default HouseView;

package/src/views/inventory/_index.mjs

@@ -0,0 +1,27 @@
+// What sinking would have to rescue: projects with their state, and ttystories.
+import { BOS } from "../../main.ts";
+import { header, pad, paint } from "../terminal/paint.mjs";
+
+export class InventoryView extends BOS.View {
+  data({ inventory }) {
+    return inventory;
+  }
+
+  text({ inventory }) {
+    const rows = inventory.projects.map(
+      ({ scope, project, branch, uncommitted }) =>
+        `  ${pad(`${scope}/${project}`, 48)} ${paint.cyan(pad(branch ?? "?", 14))} ${uncommitted ? paint.red(`${uncommitted} uncommitted`) : paint.green("clean")}`,
+    );
+    return [
+      header("sinking inventory"),
+      "",
+      paint.bold(`projects (${rows.length})`),
+      ...(rows.length ? rows : [paint.dim("  none in forge")]),
+      "",
+      paint.bold(`ttystories (${inventory.ttystories.length})`),
+      ...inventory.ttystories.map((name) => `  ${name}`),
+    ].join("\n");
+  }
+}
+
+export default InventoryView;

package/src/views/mcp/_index.mjs

@@ -0,0 +1,31 @@
+// BOS over the Model Context Protocol (stdio): every TOOLS entry becomes an MCP tool.
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+import { VERSION } from "../../core/self.mjs";
+import { READ_ONLY, TOOLS } from "./tools.mjs";
+
+export function createMcpServer(bos) {
+  const server = new McpServer({ name: "bos", version: VERSION });
+  for (const tool of TOOLS) {
+    server.registerTool(
+      tool.name,
+      { description: tool.description, inputSchema: tool.input, annotations: READ_ONLY },
+      async (args = {}) => {
+        try {
+          const output = await tool.run(bos, args);
+          return {
+            content: [{ type: "text", text: typeof output === "string" ? output : JSON.stringify(output, null, 2) }],
+          };
+        } catch (error) {
+          return { isError: true, content: [{ type: "text", text: `${tool.name}: ${error.message}` }] };
+        }
+      },
+    );
+  }
+  return server;
+}
+
+export async function startMcpServer(bos) {
+  await createMcpServer(bos).connect(new StdioServerTransport());
+}

package/src/views/mcp/tools.mjs

@@ -0,0 +1,87 @@
+// BOS as MCP tools: what an AI agent may ask the workshop. All read-only: agents look and
+// plan through MCP; changing the workshop stays a conscious act on the command line.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { z } from "zod";
+
+import { REPO_ROOT } from "../../core/self.mjs";
+
+const GLOSSARY = join(REPO_ROOT, "docs", "glossary");
+const readOnly = { readOnlyHint: true, destructiveHint: false, openWorldHint: false };
+
+export const TOOLS = [
+  {
+    name: "bos_locate",
+    description:
+      "Active BOS workshop (~/__WORKSHOP or /media/**/__WORKSHOP), the rule that found it, and where BOS itself sits.",
+    input: {},
+    run: async (bos) => bos.command("locate"),
+  },
+  {
+    name: "bos_status",
+    description:
+      "Workshop tree (.BOS, devarmory, forge, craftbook, archive): what exists and what is missing; role and mode of work.",
+    input: {},
+    run: async (bos) => bos.command("status"),
+  },
+  {
+    name: "bos_house",
+    description:
+      "The House of Anubis: adopted children, orders (RavensArmy…), bloodlines of every served model, and each resident's state. Resting residents must never be called.",
+    input: { all: z.boolean().optional().describe("also list every model per bloodline") },
+    run: async (bos, { all }) => bos.command("house", [], { all: Boolean(all) }),
+  },
+  {
+    name: "bos_glossary",
+    description:
+      "Definition of a BOS element (workshop, forge, scope, sheme, sarcophag, mode, house, raven…) from docs/glossary; without a term, the list of pages.",
+    input: { term: z.string().optional().describe("element name, e.g. forge") },
+    run: async (_bos, { term }) => {
+      if (!term)
+        return readdirSync(GLOSSARY)
+          .filter((f) => f.endsWith(".md"))
+          .map((f) => f.slice(0, -3))
+          .join("\n");
+      const page = join(GLOSSARY, `${term.toLowerCase().replace(/[^a-z0-9-]/g, "")}.md`);
+      return existsSync(page) ? readFileSync(page, "utf8") : `no glossary page for "${term}"`;
+    },
+  },
+  {
+    name: "bos_describe",
+    description:
+      "Conventional-commit draft for what is staged in a git repository (deterministic; Skryba the scribe raven only when asked, it may take up to 90 s).",
+    input: {
+      cwd: z.string().describe("path inside the repository"),
+      skryba: z.boolean().optional().describe("let Skryba refine the draft through ollama"),
+    },
+    run: async (bos, { cwd, skryba }) =>
+      (await bos.workshop.describe({ cwd, skryba: Boolean(skryba) })).message ?? "nothing staged",
+  },
+  {
+    name: "bos_promote_plan",
+    description:
+      "Plan (never apply) moving a repository's current branch one station along the flow master → developement → revision → testing → releasing → master.",
+    input: { cwd: z.string().describe("path inside the repository"), reject: z.boolean().optional() },
+    run: async (bos, { cwd, reject }) => {
+      const context = await bos.workshop.run("promoting", { cwd, reject: Boolean(reject), dryRun: true });
+      return new bos.views.PromotionView().text(context);
+    },
+  },
+  {
+    name: "bos_sink_inventory",
+    description:
+      "Read-only inventory for the sinking protocol: every forge project with branch and uncommitted changes, and the ttystories.",
+    input: {},
+    run: async (bos) => bos.command("sink"),
+  },
+  {
+    name: "bos_help",
+    description:
+      "BOS commands grouped by mode of work (ALMANAC, CONFORM, SMELTRY, COMMANDORATE, PROVISION), or the help of one command.",
+    input: { command: z.string().optional() },
+    run: async (bos, { command }) => bos.command("help", command ? [command] : []),
+  },
+];
+
+export const READ_ONLY = readOnly;

package/src/views/mode/_index.mjs

@@ -0,0 +1,34 @@
+// The modes of work as a menu, and the result of a switch.
+import { BOS } from "../../main.ts";
+import { MODES } from "../../models/workshop/modes.mjs";
+import { header, pad, paint } from "../terminal/paint.mjs";
+
+export const modeLabel = (mode) =>
+  mode ? `${paint.magenta(MODES[mode].title)} ${paint.dim(MODES[mode].covers)}` : paint.dim("not chosen: bos mode");
+
+export class ModeView extends BOS.View {
+  data({ config, previousMode, event }) {
+    return { mode: config?.mode ?? null, previousMode: previousMode ?? null, event: event ?? null };
+  }
+
+  // the chooser's menu, current mode marked
+  menu(current) {
+    return [
+      header("mode of work"),
+      "",
+      ...Object.entries(MODES).map(([name, mode]) => {
+        const mark = name === current ? paint.green("●") : " ";
+        return ` ${mark} ${paint.yellow(mode.digit)}  ${pad(paint.bold(mode.title), 14)} ${paint.dim(mode.covers)}`;
+      }),
+      `   ${paint.yellow(0)}  ${paint.dim("leave")}`,
+      "",
+    ].join("\n");
+  }
+
+  text({ config, previousMode }) {
+    if (previousMode === config.mode) return `mode stays ${modeLabel(config.mode)}`;
+    return `mode ${paint.dim(previousMode ?? "none")} ${paint.yellow("→")} ${modeLabel(config.mode)}`;
+  }
+}
+
+export default ModeView;

package/src/views/mode/chooser.mjs

@@ -0,0 +1,37 @@
+// One digit, no Enter: 0…max on a terminal. From a pipe: the first digit of the first line.
+// Anything else, Ctrl+C or end of input counts as 0 (leave).
+import readline from "node:readline";
+
+export function chooseDigit(prompt, max, { input = process.stdin, output = process.stdout } = {}) {
+  output.write(prompt);
+  return new Promise((resolve) => {
+    const done = (digit) => {
+      output.write(`${digit}\n`);
+      resolve(digit);
+    };
+    if (input.isTTY) {
+      readline.emitKeypressEvents(input);
+      input.setRawMode(true);
+      input.resume();
+      const onKey = (text, key = {}) => {
+        const digit = key.ctrl && key.name === "c" ? 0 : /^\d$/.test(text ?? "") ? Number(text) : null;
+        if (digit === null || digit > max) return;
+        input.off("keypress", onKey);
+        input.setRawMode(false);
+        input.pause();
+        done(digit);
+      };
+      input.on("keypress", onKey);
+    } else {
+      const lines = readline.createInterface({ input });
+      let answered = false;
+      lines.once("line", (line) => {
+        answered = true;
+        const digit = Number(line.trim()[0]);
+        lines.close();
+        done(Number.isInteger(digit) && digit <= max ? digit : 0);
+      });
+      lines.once("close", () => answered || done(0));
+    }
+  });
+}

package/src/views/promotion/_index.mjs

@@ -0,0 +1,20 @@
+// One station along the branch flow: from → to, and the plan.
+import { BOS } from "../../main.ts";
+import { BRANCHES } from "../../procedures/promoting/branch-flow.mjs";
+import { paint } from "../terminal/paint.mjs";
+
+export class PromotionView extends BOS.View {
+  data({ from, to, plan, dryRun, pullRequest }) {
+    return { from, to, plan, dryRun, pullRequest };
+  }
+
+  text({ from, to, plan, dryRun }) {
+    return [
+      `${paint.cyan(from)} ${paint.yellow("→")} ${paint.cyan(to)}  ${paint.dim(BRANCHES[to])}`,
+      ...plan.map((step) => `  ${paint.dim("•")} ${step}`),
+      dryRun ? paint.dim("dry run: add --apply to execute") : paint.green("applied"),
+    ].join("\n");
+  }
+}
+
+export default PromotionView;

package/src/views/repl/_index.mjs

@@ -0,0 +1,30 @@
+// Interactive BOS: every command at a prompt. A command with its own repl.mjs
+// gets the prompt to ask questions; others print their inline output.
+import readline from "node:readline/promises";
+
+import { header, paint } from "../terminal/paint.mjs";
+
+export async function startRepl(bos) {
+  const io = readline.createInterface({ input: process.stdin, output: process.stdout });
+  console.log(header("BOS repl"), paint.dim("· help · exit"));
+  io.setPrompt(paint.yellow("⚒ bos › "));
+  io.prompt();
+  for await (const line of io) {
+    const [name, ...operands] = line.trim().split(/\s+/).filter(Boolean);
+    if (name === "exit" || name === "quit") break;
+    if (name) {
+      try {
+        const command = bos.commands[name];
+        if (!command) throw new Error(`unknown command "${name}"`);
+        const output = command.repl
+          ? await command.repl({ bos, operands, flags: bos.options, io })
+          : await command.inline({ bos, operands, flags: bos.options });
+        if (output) console.log(typeof output === "string" ? output : JSON.stringify(output, null, 2));
+      } catch (error) {
+        console.log(paint.red(error.message));
+      }
+    }
+    io.prompt();
+  }
+  io.close();
+}

package/src/views/skills/_index.mjs

@@ -0,0 +1,24 @@
+// Which model has a skill, which got a fresh draft.
+import { BOS } from "../../main.ts";
+import { header, pad, paint } from "../terminal/paint.mjs";
+
+export class SkillsView extends BOS.View {
+  data({ skills, registered, dryRun }) {
+    return { skills: skills.map(({ name, created }) => ({ name, created })), registered, dryRun };
+  }
+
+  text({ skills, registered = [], dryRun }) {
+    const state = (created) => (created ? paint.green(dryRun ? "+ would draft" : "+ drafted") : paint.dim("● exists"));
+    return [
+      header("skills"),
+      "",
+      ...skills.map(({ name, created }) => `  ${pad(paint.cyan(name), 24)} ${state(created)}`),
+      "",
+      registered.length
+        ? `${dryRun ? "would register" : "registered"} ${registered.length} in marketplace.json`
+        : paint.dim("marketplace up to date"),
+    ].join("\n");
+  }
+}
+
+export default SkillsView;

package/src/views/status/_index.mjs

@@ -0,0 +1,57 @@
+// The state of a workshop: where it is, its role, where BOS sits, its tree, what changed.
+import { BOS } from "../../main.ts";
+import { HOST_ROLES } from "../../models/workshop/host-roles.mjs";
+import { modeLabel } from "../mode/_index.mjs";
+import { field, header, paint } from "../terminal/paint.mjs";
+import { drawTree } from "./tree.mjs";
+
+function place(self) {
+  if (!self?.place) return paint.dim("outside the active workshop");
+  const { area, scope, project } = self.place;
+  return [area, scope, project].filter(Boolean).join(paint.dim(" / ")) || "workshop root";
+}
+
+export class StatusView extends BOS.View {
+  data(context) {
+    const { workshopRoot, workshopSource, workshops, config, defaulted, tree, self, changes, dryRun, event } = context;
+    return { workshopRoot, workshopSource, workshops, config, defaulted, tree, self, changes, dryRun, event };
+  }
+
+  text(context) {
+    const lines = [header("Blacksmith Organization System"), ""];
+    lines.push(field("workshop", `${context.workshopRoot} ${paint.dim(`(${context.workshopSource})`)}`));
+    if (context.config) {
+      const { role } = context.config;
+      const byDefault = (key) => (context.defaulted?.includes(key) ? paint.dim("  (default)") : "");
+      lines.push(
+        field(
+          "role",
+          (role
+            ? `${paint.cyan(role)} ${paint.dim(HOST_ROLES[role])}`
+            : paint.dim('not set: .BOS/workshop.json "role"')) + byDefault("role"),
+        ),
+      );
+      lines.push(field("mode", modeLabel(context.config.mode) + byDefault("mode")));
+    }
+    lines.push(field("BOS", `${paint.bold(`v${context.self.version}`)} ${paint.dim("·")} ${place(context.self)}`));
+    const others = context.workshops.filter((path) => path !== context.workshopRoot);
+    if (others.length) lines.push(field("others", others.join("\n          ")));
+    const snapshot = context.tree ?? context.workshop?.inspect();
+    if (snapshot) lines.push("", drawTree(snapshot));
+    if (context.changes?.length) {
+      lines.push(
+        "",
+        paint.bold(context.dryRun ? "would create" : "created"),
+        ...context.changes.map((path) => `  ${paint.green("+")} ${path}`),
+      );
+    }
+    if (context.event)
+      lines.push(
+        "",
+        field("recorded", `${paint.magenta(context.event.event)} ${paint.dim(`@ ${context.event.unixusat}`)}`),
+      );
+    return lines.join("\n");
+  }
+}
+
+export default StatusView;

package/src/views/status/tree.mjs

@@ -0,0 +1,19 @@
+// The workshop tree drawn with branches and a colored state per area.
+import { basename } from "node:path";
+
+import { pad, paint } from "../terminal/paint.mjs";
+
+const mark = (node) =>
+  node.exists ? paint.green("●  ok") : node.mandatory ? paint.red("○  missing") : paint.dim("·  not yet");
+
+export function drawTree(node, prefix = "", last = true, root = true) {
+  const branch = root ? "" : last ? "└── " : "├── ";
+  const name = root ? paint.bold(node.path) : basename(node.path);
+  const label = pad(`${prefix}${branch}${name}`, root ? 0 : 40);
+  const line = root ? label : `${label} ${paint.dim(pad(node.type, 12))} ${mark(node)}`;
+  const childPrefix = root ? "" : prefix + (last ? "    " : "│   ");
+  return [
+    line,
+    ...node.children.map((child, i) => drawTree(child, childPrefix, i === node.children.length - 1, false)),
+  ].join("\n");
+}

package/src/views/terminal/paint.mjs

@@ -0,0 +1,22 @@
+// ANSI colors for terminals; plain text for pipes, files and NO_COLOR.
+const enabled = process.stdout.isTTY && !process.env.NO_COLOR;
+const code = (open, close) => (text) => (enabled ? `\x1b[${open}m${text}\x1b[${close}m` : String(text));
+
+export const paint = {
+  bold: code(1, 22),
+  dim: code(2, 22),
+  red: code(31, 39),
+  green: code(32, 39),
+  yellow: code(33, 39),
+  blue: code(34, 39),
+  magenta: code(35, 39),
+  cyan: code(36, 39),
+};
+
+// visible length, ignoring color codes
+// biome-ignore lint/suspicious/noControlCharactersInRegex: \x1b starts the ANSI color codes this strips
+export const width = (text) => String(text).replace(/\x1b\[\d+m/g, "").length;
+export const pad = (text, size) => text + " ".repeat(Math.max(0, size - width(text)));
+
+export const header = (title) => paint.bold(paint.yellow(`⚒  ${title}`));
+export const field = (label, value) => `${paint.dim(pad(label, 10))}${value}`;

package/template/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: skill-name
+description: What this skill does and when an agent should use it. [`TODO`]
+---
+
+# Skill Name
+
+[`TODO`] Instructions the agent follows when this skill is active.
+
+## When to use
+
+[`TODO`]
+
+## Instructions
+
+[`TODO`]

package/docs/README.md

@@ -1,15 +0,0 @@
-
-```
-************************************
-   Part of R tier project "ANUBIS"
-     ______    _____    _____
-     | ___ \  |  _  |  /  ___|
-     | |_/ /  | | | |  \ `--.
-     | ___ \  | | | |   `--. \
-     | |_/ /  \ \_/ /  /\__/ /
-     \____(_)  \___(_) \____(_)
-
-    By Sett Sarverott @ 2019-2024
-************************************
-     Version: 0.2.0 (PreAlfa_#1)
-```

package/docs/devlog.md

@@ -1,20 +0,0 @@
-# ENTRY 1:
-this is huge mess, i had overartistic phase about code, because of lack of reasoning in work. now it's time to list things to cutoff:
-  - strange require builder in libraries.js: i remember why it was like that - for easy morphing into browser-only service system... but it's dumb implementation of this idea, i had no clear idea how to do that
-  - every referencable var in module will be prioritized to be global scoped exclusively in file for reduction of too long reference chains and information noise generation by bad readability caused by text overwhelmnes in result
-  - prettification of staff
-  -
-
-# entry 2:
-model is autodeclaring own internals
-> model directory:
- - **class.js** - declaration of model
- - ~fundation.json~ **index.json** - data structure of model
- - **README.md** - about that type
- - _**actions**_ - _DIR_ commands and available acts
- - _**listeners**_ - _DIR_ all watchers and other stuff
- - _**events**_ - _DIR_ basic behaviour
- - _**extenders**_ - _DIR_ flat extension for every new object, produced by class.js
- - _**methods**_ - _DIR_ synchronous static functions, resulting with return values
-
-# entry 3: