create-evda 0.1.5 → 0.1.6

package/lib/work.mjs

@@ -0,0 +1,180 @@
+// The `work` role, read (Spec 07 section 2, "work is live data", HQ-1371).
+//
+// A record's work is its efforts, each with a status and a date. The role names where they are:
+//
+//   "work": "harlequin:"            THE HARLEQUIN, every board project whose `dev_projects.vault_path`
+//                                   lies in this record (and not in one of its sub-records)
+//   "work": "harlequin:<project>"   THE HARLEQUIN, that one project
+//   "work": { "source": "harlequin", "project": "<id>" }   the same, as an object
+//   "work": "<folder>"              a folder of effort files, one per effort, whose frontmatter
+//                                   carries `status` (required) and `planned_for` (YYYY-MM-DD, optional)
+//
+// One view reads either and prints `CHECKED <n> efforts`. Status is a field, never a move: a
+// finished effort is a value of `status`, not a file somewhere else.
+//
+// The board is read, never written: two GETs against Supabase's REST interface with the service
+// key from the environment (SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY) or an env file the caller
+// names. Nothing about the credentials is printed or kept. Without them, or offline, the view says
+// SKIPPED and why; it never prints a pass it did not earn.
+//
+// `vault_path` is relative to the board owner's outermost record, so a sub-record's projects are
+// found by its offset from that root: the Iris record's projects are those whose vault_path lies
+// under 01_Projects/Evda/Iris... and in none of Iris's own sub-records.
+//
+// EVDA_WORK_FALSIFY=<mode,...> breaks one guarantee on purpose, for the tests:
+//   all-projects     every board project is this record's, whatever its vault_path says
+//   drop-efforts     the source is read and its efforts are thrown away
+//   skip-as-pass     no credentials is reported as CHECKED 0 and a pass
+//   no-status        a folder effort with no status is counted as one
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { fourRoles, workSource } from "./roles.mjs";
+import { findRoot } from "./manifest.mjs";
+import { subRecords } from "./records.mjs";
+import { mdFiles } from "./record.mjs";
+import { frontmatterOf } from "./circles.mjs";
+import { FOLDER_MANIFEST } from "./folders.mjs";
+
+export const FALSIFY_MODES = ["all-projects", "drop-efforts", "skip-as-pass", "no-status"];
+const falsified = (mode, env) => [env.EVDA_WORK_FALSIFY, process.env.EVDA_WORK_FALSIFY].join(",").split(",").map((s) => s.trim()).includes(mode);
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+const posix = (p) => p.split(sep).join("/");
+
+// The outermost record above `dir` (itself when there is none), and `dir`'s path inside it.
+export function offsetInTop(dir) {
+  let top = dir;
+  for (let up = findRoot(dirname(top)); up && up !== top; up = findRoot(dirname(up))) top = up;
+  return { top, offset: posix(relative(top, dir)) };
+}
+
+// The board projects that belong to the record at `dir`: named, or matched by vault_path.
+export function projectsFor(dir, projects, { project = null, env = process.env } = {}) {
+  if (project) return projects.filter((p) => p.id === project).map((p) => ({ ...p, by: "named" }));
+  if (falsified("all-projects", env)) return projects.map((p) => ({ ...p, by: "vault_path" }));
+  const { top, offset } = offsetInTop(dir);
+  const subs = subRecords(dir).map((s) => (offset ? `${offset}/${s}` : s));
+  const under = (v, root) => root === "" || v === root || v.startsWith(`${root}/`);
+  return projects
+    // A vault_path names a place in the owner's outermost record; one that is not there belongs to
+    // no record, since nothing on disk says whose it is.
+    .filter((p) => typeof p.vault_path === "string" && p.vault_path !== "" && existsSync(join(top, p.vault_path)))
+    .filter((p) => under(p.vault_path, offset) && !subs.some((s) => under(p.vault_path, s)))
+    .map((p) => ({ ...p, by: "vault_path" }));
+}
+
+// KEY=VALUE lines, quotes stripped. Only the two keys the connector needs are kept.
+export function readEnvFile(path) {
+  const out = {};
+  for (const raw of readFileSync(path, "utf8").split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || !line.includes("=")) continue;
+    const at = line.indexOf("=");
+    const k = line.slice(0, at).trim();
+    if (k === "SUPABASE_URL" || k === "SUPABASE_SERVICE_ROLE_KEY") out[k] = line.slice(at + 1).trim().replace(/^["']|["']$/g, "");
+  }
+  return out;
+}
+
+async function getAll(fetchFn, url, key, path) {
+  const rows = [];
+  for (let from = 0; ; from += 1000) {
+    const res = await fetchFn(`${url}/rest/v1/${path}`, { headers: { apikey: key, Authorization: `Bearer ${key}`, Range: `${from}-${from + 999}`, "Range-Unit": "items" } });
+    if (!res.ok && res.status !== 206) throw new Error(`the board answered ${res.status} for ${path.split("?")[0]}`);
+    const page = await res.json();
+    rows.push(...page);
+    if (page.length < 1000) return rows;
+  }
+}
+
+// Efforts from THE HARLEQUIN. Returns { status: "checked" | "skipped" | "failed", ... }.
+export async function harlequinEfforts(dir, { project = null, env = process.env, envFile = null, fetchFn = globalThis.fetch } = {}) {
+  let creds = { SUPABASE_URL: env.SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY: env.SUPABASE_SERVICE_ROLE_KEY };
+  if (envFile) {
+    if (!existsSync(envFile)) return { status: "skipped", why: `the env file ${envFile} does not exist` };
+    creds = { ...creds, ...readEnvFile(envFile) };
+  }
+  if (!creds.SUPABASE_URL || !creds.SUPABASE_SERVICE_ROLE_KEY) {
+    if (falsified("skip-as-pass", env)) return { status: "checked", efforts: [], projects: [] };
+    return { status: "skipped", why: "THE HARLEQUIN is read with SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY, and neither the environment nor --env-file gave both" };
+  }
+  if (typeof fetchFn !== "function") return { status: "skipped", why: "this runtime has no fetch" };
+  const url = creds.SUPABASE_URL.replace(/\/+$/, "");
+  const key = creds.SUPABASE_SERVICE_ROLE_KEY;
+  let all;
+  try {
+    all = await getAll(fetchFn, url, key, "dev_projects?select=id,vault_path&order=id");
+  } catch (e) {
+    return { status: "skipped", why: `the board could not be read (${e.cause?.code ?? e.message}); offline or unreachable` };
+  }
+  const mine = projectsFor(dir, all, { project, env });
+  if (project && mine.length === 0) return { status: "failed", why: `the board has no project "${project}"` };
+  if (mine.length === 0) return { status: "failed", why: `no board project's vault_path lies in this record (${offsetInTop(dir).offset || "the root"}); name one with "harlequin:<project>" or map work to a folder` };
+  let items;
+  try {
+    items = await getAll(fetchFn, url, key, `dev_items?select=number,title,status,planned_for,project_id&project_id=in.(${mine.map((p) => p.id).join(",")})&order=number`);
+  } catch (e) {
+    return { status: "skipped", why: `the board's tickets could not be read (${e.cause?.code ?? e.message})` };
+  }
+  let efforts = items.map((i) => ({ id: `HQ-${i.number}`, title: i.title, status: i.status, planned_for: i.planned_for ?? null, project: i.project_id }));
+  if (falsified("drop-efforts", env)) efforts = [];
+  return { status: "checked", efforts, projects: mine };
+}
+
+// Efforts from a folder of effort files. Every problem is a sentence; an effort with no status is
+// a problem, never an effort.
+export function folderEfforts(evda, entry, { env = process.env } = {}) {
+  const efforts = [];
+  const problems = [];
+  if (!entry.exists || !entry.isDir) return { status: "failed", why: `${entry.rel} is not a folder`, efforts, problems };
+  for (const abs of mdFiles(entry.abs)) {
+    if (abs.endsWith(`/${FOLDER_MANIFEST}`)) continue;
+    const rel = posix(relative(evda.dir, abs));
+    const text = readFileSync(abs, "utf8");
+    const front = frontmatterOf(text) ?? {};
+    const status = typeof front.status === "string" ? front.status.trim() : "";
+    if (!status && !falsified("no-status", env)) { problems.push(`${rel} is in the work folder ${entry.rel} and has no status. An effort carries its status as a field.`); continue; }
+    const planned = front.planned_for ?? null;
+    if (planned !== null && !(typeof planned === "string" && DAY.test(planned))) { problems.push(`${rel} has planned_for ${JSON.stringify(planned)}; it is a date, YYYY-MM-DD.`); continue; }
+    const title = /^# (.+)$/m.exec(text)?.[1]?.trim() ?? rel.split("/").pop().replace(/\.md$/, "");
+    efforts.push({ id: rel, title, status: status || "(none)", planned_for: planned, project: null });
+  }
+  return { status: "checked", efforts, problems };
+}
+
+const tally = (efforts) => {
+  const by = {};
+  for (const e of efforts) by[e.status] = (by[e.status] ?? 0) + 1;
+  return Object.entries(by).sort((a, b) => b[1] - a[1]).map(([s, n]) => `${n} ${s}`).join(", ");
+};
+
+// The view: every work entry read, one CHECKED or SKIPPED line each, and FAIL lines. Returns
+// { lines, efforts, exit }. exit 0 when every entry printed CHECKED n > 0 or SKIPPED with its reason
+// (zero efforts is a SKIPPED, never a CHECKED 0), 1 on a failure, 2 when the record declares no work.
+export async function readWork(evda, { env = process.env, envFile = null, fetchFn = globalThis.fetch } = {}) {
+  const four = fourRoles(evda, { subRecords: subRecords(evda.dir) });
+  const lines = [];
+  const efforts = [];
+  let failed = false;
+  if (four.roles.work.length === 0) return { lines: [`SKIPPED efforts: this record maps no "work" role`], efforts, exit: 2 };
+  for (const p of four.problems.filter((x) => /^"work/.test(x))) { lines.push(`FAIL  ${p}`); failed = true; }
+  for (const entry of four.roles.work) {
+    if (entry.source) {
+      const r = await harlequinEfforts(evda.dir, { project: entry.source.project, env, envFile, fetchFn });
+      if (r.status === "skipped") { lines.push(`SKIPPED efforts from ${entry.source.source}: ${r.why}`); continue; }
+      if (r.status === "failed") { lines.push(`FAIL  ${entry.key}  ${r.why}`); failed = true; continue; }
+      const names = r.projects.map((p) => `${p.id}${p.by === "vault_path" ? ` (${p.vault_path})` : ""}`).join(", ");
+      if (r.efforts.length === 0) { lines.push(`SKIPPED efforts from ${entry.source.source}: ${r.projects.length} project(s) (${names}) and the board holds no ticket in them. Nothing was checked, so nothing passed.`); continue; }
+      lines.push(`CHECKED ${r.efforts.length} efforts  from ${entry.source.source}, ${r.projects.length} project(s) ${r.projects[0]?.by === "named" ? "named" : "by vault_path"}: ${names}; ${tally(r.efforts)}`);
+      efforts.push(...r.efforts);
+    } else {
+      const r = folderEfforts(evda, entry, { env });
+      for (const p of r.problems) { lines.push(`FAIL  ${p}`); failed = true; }
+      if (r.status === "failed") { lines.push(`FAIL  ${entry.key}  ${r.why}`); failed = true; continue; }
+      if (r.efforts.length === 0) { lines.push(`SKIPPED efforts from the folder ${entry.rel}: it holds no effort file yet. Nothing was checked, so nothing passed.`); continue; }
+      lines.push(`CHECKED ${r.efforts.length} efforts  from the folder ${entry.rel}: ${tally(r.efforts)}`);
+      efforts.push(...r.efforts);
+    }
+  }
+  return { lines, efforts, exit: failed ? 1 : 0 };
+}

package/lib/yaml.mjs

@@ -2,7 +2,8 @@
 //
 // The substrate writes an eco as `eco.yaml`, and this package has no runtime dependencies, so the
 // subset of YAML an eco manifest uses is read and written here: comments, block mappings, block
-// sequences, plain and quoted scalars, block scalars (`|`, `>`), and one level of flow collections.
+// sequences, plain and quoted scalars, block scalars (`|`, `>`, with chomping and indentation
+// indicators), and one level of flow collections.
 // Anchors, aliases, tags, multi-document streams and tab indentation are refused with a line
 // number rather than guessed at. `test/yaml.test.mjs` checks this reader against the `yaml`
 // package over the substrate's own manifests, so the two agree on every file that matters.
@@ -48,6 +49,13 @@ function lines(text) {
   return out;
 }
 
+// Set a parsed key as an own property. A plain `out[key] = v` treats "__proto__" as the prototype,
+// and `key in out` finds "toString" and "constructor" on every object, so a frontmatter key named
+// like an Object method read as a duplicate (HQ-1406).
+function put(out, key, value) {
+  Object.defineProperty(out, key, { value, enumerable: true, writable: true, configurable: true });
+}
+
 const PLAIN_BOOL = { true: true, false: false, True: true, False: false, TRUE: true, FALSE: false };
 const NULLS = new Set(["null", "Null", "NULL", "~", ""]);
 
@@ -125,7 +133,7 @@ function flow(t, no) {
         skip();
         if (peek() !== ":") fail(no, "expected : in flow mapping");
         i++;
-        out[String(k)] = value();
+        put(out, String(k), value(), no);
         skip();
         if (peek() === ",") { i++; continue; }
         if (peek() === "}") { i++; return out; }
@@ -147,8 +155,10 @@ function splitKey(text, no) {
   let key;
   if (text[0] === '"' || text[0] === "'") {
     const q = text[0];
+    // An escaped quote inside a double-quoted key does not end it: the writer quotes a key with
+    // JSON.stringify, so `"a\"b"` is one key (HQ-1406).
     let j = 1;
-    while (j < text.length && text[j] !== q) j++;
+    while (j < text.length && text[j] !== q) j += q === '"' && text[j] === "\\" ? 2 : 1;
     if (j >= text.length) fail(no, "unterminated quoted key");
     key = scalar(text.slice(0, j + 1), no);
     i = j + 1;
@@ -162,39 +172,92 @@ function splitKey(text, no) {
   return { key: String(key), rest: text.slice(i + 1).trim() };
 }
 
-function blockScalar(header, ls, i, parentIndent, no) {
-  const m = /^([|>])([-+]?)$/.exec(header);
+// A block scalar (`|` or `>`) is read from the raw text lines, not from lines(): its body keeps
+// what lines() drops, a `#` line, a leading or trailing blank line, a whitespace-only line (HQ-1409).
+// YAML 1.2 rules: the indentation is the header's indicator over the parent's, or else the first
+// non-blank line's; the body ends at the first non-blank line indented less; `>` folds a line break
+// between two lines that do not start with whitespace; `-` strips the final newlines, `+` keeps
+// them all, and the default keeps one. Where the spec leaves a corner open (a whitespace-only line
+// at the end, a text with no final line break) this reads it as the `yaml` package does, since
+// every other tool that reads these files uses it. `src` is the text's lines, `no` the header's.
+function blockScalar(header, ls, i, parentIndent, no, src) {
+  const m = /^([|>])(?:([-+]?)([1-9]?)|([1-9])([-+]))$/.exec(header);
   if (!m) fail(no, `unsupported block scalar header ${header}`);
   const fold = m[1] === ">";
-  const chomp = m[2];
-  const body = [];
-  let j = i;
-  let blockIndent = null;
-  while (j < ls.length && ls[j].indent > parentIndent) {
-    if (blockIndent === null) blockIndent = ls[j].indent;
-    body.push({ text: ls[j].raw.slice(blockIndent), blank: false, no: ls[j].no });
-    j++;
+  const chomp = m[2] || m[5] || "";
+  const indicator = Number(m[3] || m[4] || 0);
+  // The text's final line break ends its last line; it does not open another one.
+  const last = src.length > 0 && src[src.length - 1].replace(/\r$/, "") === "" ? src.length - 1 : src.length;
+  const raw = (k) => src[k].replace(/\r$/, "");
+  const spaces = (l) => l.length - l.replace(/^ +/, "").length;
+  const blank = (l) => /^ *$/.test(l);
+  let first = null; // the first non-blank line's indentation
+  for (let k = no; k < last; k++) {
+    const l = raw(k);
+    if (blank(l)) continue;
+    if (spaces(l) > parentIndent) first = spaces(l);
+    break;
+  }
+  // With no content line, every line up to the next less-indented one is blank, however long.
+  const indent = indicator ? parentIndent + indicator : first ?? Infinity;
+  const lines = []; // each line: its text past the indentation, or null when blank
+  let k = no;
+  for (; k < last; k++) {
+    const l = raw(k);
+    if (blank(l)) { lines.push({ text: l.length > indent ? l.slice(indent) : null, len: l.length }); continue; }
+    if (spaces(l) < indent) {
+      if (/^ *\t/.test(l)) fail(k + 1, "tab indentation");
+      break;
+    }
+    lines.push({ text: l.slice(indent), len: l.length });
+  }
+  const open = k === last && last === src.length; // the block ends the text, with no final line break
+  const hasContent = lines.some((l) => l.text !== null && !blank(l.text));
+  if (!hasContent) {
+    if (chomp !== "+" || lines.length === 0) return done("");
+    return done("\n".repeat(Math.max(1, lines.length - (open ? 1 : 0))));
+  }
+  // YAML refuses a leading blank line indented past the block, since it would decide the indentation.
+  if (!indicator) {
+    for (let b = 0; b < lines.length && (lines[b].text === null || blank(lines[b].text)); b++) {
+      if (lines[b].text !== null) fail(no + b + 1, "a leading all-space line is indented past the block; give the header an indentation indicator");
+    }
   }
-  // Blank lines inside a block scalar were dropped by lines(); recover them from line numbers.
-  const withBlanks = [];
-  for (let k = 0; k < body.length; k++) {
-    if (k > 0) for (let g = body[k - 1].no + 1; g < body[k].no; g++) withBlanks.push("");
-    withBlanks.push(body[k].text);
+  // Without `+`, a whitespace-only last line no longer than the first content line is not content.
+  let end = lines.length;
+  for (;;) {
+    while (end > 0 && lines[end - 1].text === null) end--;
+    if (chomp !== "+" && end > 0 && blank(lines[end - 1].text) && lines[end - 1].len <= first) { lines[--end].text = null; continue; }
+    break;
   }
-  let text;
+  const content = lines.slice(0, end).map((l) => l.text ?? "");
+  let text = "";
   if (fold) {
-    text = withBlanks.reduce((acc, l, k) => {
-      if (k === 0) return l;
-      if (l === "") return acc + "\n";
-      return acc.endsWith("\n") ? acc + l : acc + " " + l;
-    }, "");
+    const moreIndented = (l) => /^[ \t]/.test(l);
+    let prev = null;
+    let empties = 0;
+    for (const l of content) {
+      if (l === "") { empties++; continue; }
+      if (prev === null) text += "\n".repeat(empties);
+      else if (!moreIndented(prev) && !moreIndented(l)) text += empties === 0 ? " " : "\n".repeat(empties);
+      else text += "\n".repeat(empties + 1);
+      text += l;
+      prev = l;
+      empties = 0;
+    }
   } else {
-    text = withBlanks.join("\n");
+    text = content.join("\n");
+  }
+  if (chomp === "-") return done(text);
+  if (chomp === "") return done(text + "\n");
+  // `+` keeps the content line's break and one per blank line after it that ends in a line break.
+  return done(text + "\n" + "\n".repeat(Math.max(0, lines.length - end - (open ? 1 : 0))));
+
+  function done(value) {
+    let j = i;
+    while (j < ls.length && ls[j].no <= k) j++;
+    return { value, next: j };
   }
-  if (chomp === "-") text = text.replace(/\n+$/, "");
-  else if (chomp === "+") text = text + "\n";
-  else text = text.replace(/\n+$/, "") + "\n";
-  return { value: text, next: j };
 }
 
 function parseBlock(ls, i, indent) {
@@ -220,7 +283,7 @@ function parseSeq(ls, i, indent) {
       // `- key: value` opens a mapping whose remaining keys sit two columns in.
       const itemIndent = indent + 2;
       const synthetic = new Line(itemIndent, rest, l.no);
-      synthetic.raw = " ".repeat(itemIndent) + rest;
+      synthetic.src = l.src;
       const sub = [synthetic];
       let j = i + 1;
       while (j < ls.length && ls[j].indent >= itemIndent) sub.push(ls[j++]);
@@ -229,8 +292,8 @@ function parseSeq(ls, i, indent) {
       i = j;
       continue;
     }
-    if (/^[|>][-+]?$/.test(rest)) {
-      const r = blockScalar(rest, ls, i + 1, indent, l.no);
+    if (/^[|>][-+1-9]*$/.test(rest)) {
+      const r = blockScalar(rest, ls, i + 1, indent, l.no, l.src);
       out.push(r.value);
       i = r.next;
       continue;
@@ -248,30 +311,30 @@ function parseMap(ls, i, indent) {
     const l = ls[i];
     const kv = splitKey(l.text, l.no);
     if (!kv) fail(l.no, `expected a key, got: ${l.text}`);
-    if (kv.key in out) fail(l.no, `duplicate key ${kv.key}`);
+    if (Object.hasOwn(out, kv.key)) fail(l.no, `duplicate key ${kv.key}`);
     if (kv.rest === "") {
       const nx = ls[i + 1];
       if (nx && nx.indent > indent) {
         const r = parseBlock(ls, i + 1, nx.indent);
-        out[kv.key] = r.value;
+        put(out, kv.key, r.value);
         i = r.next;
       } else if (nx && nx.indent === indent && (nx.text.startsWith("- ") || nx.text === "-")) {
         const r = parseSeq(ls, i + 1, indent);
-        out[kv.key] = r.value;
+        put(out, kv.key, r.value);
         i = r.next;
       } else {
-        out[kv.key] = null;
+        put(out, kv.key, null);
         i++;
       }
       continue;
     }
-    if (/^[|>][-+]?$/.test(kv.rest)) {
-      const r = blockScalar(kv.rest, ls, i + 1, indent, l.no);
-      out[kv.key] = r.value;
+    if (/^[|>][-+1-9]*$/.test(kv.rest)) {
+      const r = blockScalar(kv.rest, ls, i + 1, indent, l.no, l.src);
+      put(out, kv.key, r.value);
       i = r.next;
       continue;
     }
-    out[kv.key] = scalar(kv.rest, l.no);
+    put(out, kv.key, scalar(kv.rest, l.no));
     i++;
   }
   if (i < ls.length && ls[i].indent > indent) fail(ls[i].no, `unexpected indentation (${ls[i].indent} columns)`);
@@ -281,7 +344,7 @@ function parseMap(ls, i, indent) {
 export function parseYaml(text) {
   const ls = lines(text);
   const raws = text.split("\n");
-  for (const l of ls) l.raw = raws[l.no - 1];
+  for (const l of ls) l.src = raws;
   if (ls.length === 0) return null;
   const r = parseBlock(ls, 0, ls[0].indent);
   if (r.next < ls.length) fail(ls[r.next].no, `unexpected content after the document: ${ls[r.next].text}`);
@@ -304,6 +367,18 @@ function scalarOut(v) {
   return v;
 }
 
+// Whether a multi-line string is written as a `|` block. A string whose block would need a header
+// indicator (a leading blank or indented first line, kept trailing newlines) or would carry a `#`,
+// a carriage return or trailing whitespace is written double-quoted instead, which always reads
+// back and reads the same in every YAML tool (HQ-1406: "\na" read back as "a").
+function blockSafe(v) {
+  const body = v.endsWith("\n") ? v.slice(0, -1) : v;
+  if (body.endsWith("\n") || body.includes("\r") || body.includes("#")) return false;
+  const ls = body.split("\n");
+  if (ls[0] === "" || /^\s/.test(ls[0])) return false;
+  return ls.every((l) => !/\s$/.test(l));
+}
+
 function isScalar(v) {
   return v === null || v === undefined || ["string", "number", "boolean"].includes(typeof v);
 }
@@ -330,7 +405,7 @@ function write(v, indent, out) {
     for (const k of keys) {
       const val = v[k];
       const key = scalarOut(k);
-      if (typeof val === "string" && val.includes("\n")) {
+      if (typeof val === "string" && val.includes("\n") && blockSafe(val)) {
         const body = val.replace(/\n$/, "");
         out.push(`${pad}${key}: ${val.endsWith("\n") ? "|" : "|-"}`);
         for (const l of body.split("\n")) out.push(l === "" ? "" : `${pad}  ${l}`);

package/package.json

@@ -1,17 +1,32 @@
 {
   "name": "create-evda",
-  "version": "0.1.5",
-  "description": "Make your own EVÐA: a running journal of your life with Iris, as plain files on your machine, for any AI. Connect Claude Code, Codex or the Claude app over MCP. No runtime dependencies.",
+  "version": "0.1.6",
   "type": "module",
+  "description": "The person layer over the substrate: scaffold and operate an EVDA, a directory that knows what it is. Plain files are the truth, the tooling is optional, and there are no runtime dependencies.",
   "bin": {
-    "create-evda": "create-evda.mjs",
-    "evda": "bin/evda.mjs"
+    "create-evda": "./create-evda.mjs",
+    "evda": "./bin/evda.mjs"
   },
   "engines": {
     "node": ">=20"
   },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "lint": "node scripts/dashes-check.mjs && node scripts/build-templates.mjs --check && node scripts/build-kinds.mjs --check",
+    "templates:build": "node scripts/build-templates.mjs",
+    "templates:check": "node scripts/build-templates.mjs --check",
+    "kinds:build": "node scripts/build-kinds.mjs",
+    "kinds:check": "node scripts/build-kinds.mjs --check",
+    "dashes:check": "node scripts/dashes-check.mjs",
+    "vectors:both": "bash scripts/vectors-both.sh",
+    "doctor": "node bin/evda.mjs doctor",
+    "publish:dry": "node scripts/publish.mjs",
+    "publish:live": "node scripts/publish.mjs --publish"
+  },
   "files": [
     "bin",
+    "hooks",
+    "docs",
     "lib",
     "templates",
     "skills",
@@ -19,16 +34,10 @@
     "presets",
     "create-evda.mjs",
     "README.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "evda",
-    "personal-record",
-    "agents",
-    "markdown",
-    "mcp"
+    "CHANGELOG.md"
   ],
-  "author": "Mike Veson",
-  "license": "MIT",
-  "homepage": "https://evda.io"
+  "atlas": {
+    "tier": "block",
+    "domain": "neutral"
+  }
 }

package/presets/journal/preset.json

@@ -5,7 +5,15 @@
   "folders": [
     { "path": "Journal", "type": "record", "note": "One file per day, named YYYY-MM-DD.md." },
     { "path": "Captures", "type": "capture", "note": "A thought as it arrived." },
+    { "path": "Work", "type": "ticket", "note": "One file per thing being done, with its status and the day it is planned for." },
     { "path": "People", "type": "person", "connectors": ["contacts"], "note": "One file per person." },
     { "path": "Notes", "type": "concept", "note": "Ideas worth keeping past the day." }
-  ]
+  ],
+  "mapping": {
+    "journal": "Journal",
+    "journal/captures": "Captures",
+    "work": "Work",
+    "collections": "People",
+    "knowledge": "Notes"
+  }
 }

package/presets/projects-and-areas/preset.json

@@ -1,27 +1,34 @@
 {
   "id": "projects-and-areas",
   "title": "Projects and areas",
-  "for": "Someone running several projects and parts of life at once, who captures fast, sorts later, and looks back each week.",
+  "for": "Someone running several projects and parts of life at once, courses included, who captures fast, sorts later, and looks back each week.",
   "folders": [
-    { "path": "00_Inbox", "note": "Anything not sorted yet." },
-    { "path": "01_Projects", "type": "project", "note": "Work with an end: one folder per project." },
+    { "path": "01_Projects", "type": "project", "note": "One folder per project; a finished one stays here with its status." },
     { "path": "02_Areas", "note": "Parts of life with no end date: one folder per area." },
-    { "path": "02_Areas/Academics", "note": "One folder per course below this one, typed course." },
+    { "path": "02_Areas/Academics", "type": "course", "note": "One folder per course; a course is a collection like any other." },
     { "path": "02_Areas/Relationships/People", "type": "person", "connectors": ["contacts"], "note": "One file per person." },
-    { "path": "03_Resources", "note": "Reference material kept for later." },
+    { "path": "03_Resources", "note": "What is known, each page citing where it came from." },
     { "path": "03_Resources/Raw", "type": "source", "connectors": ["url"], "note": "Sources as they arrived, unedited." },
     { "path": "03_Resources/Wiki/Concepts", "type": "concept", "note": "One page per recurring idea, named." },
     { "path": "03_Resources/Wiki/Syntheses", "type": "concept", "note": "Connections worked out across ideas." },
     { "path": "03_Resources/Wiki/Sources", "type": "source", "connectors": ["url"], "note": "A summary per source cited often." },
-    { "path": "04_Archive", "note": "Finished or dropped, kept as it was." },
+    { "path": "04_Work", "type": "ticket", "note": "One file per effort, with its status and the day it is planned for; a board can take its place." },
     { "path": "05_Process", "type": "capture", "note": "Captures waiting to be filed." },
     { "path": "05_Process/Processed", "type": "capture", "note": "Captures already filed, kept." },
     { "path": "05_Process/_media", "type": "blob", "note": "Photos and audio a capture carried." },
-    { "path": "06_Metadata", "note": "The record about the record." },
     { "path": "06_Metadata/Daily Journal", "type": "record", "note": "One file per day, named YYYY-MM-DD.md." },
     { "path": "06_Metadata/Weekly Reviews", "type": "concept", "note": "One look back per week." },
-    { "path": "06_Metadata/Templates", "note": "Note templates." },
-    { "path": "07_Attachments", "note": "Files notes link to." }
+    { "path": "07_Attachments", "type": "blob", "note": "Files notes link to." }
   ],
+  "mapping": {
+    "journal": "06_Metadata/Daily Journal",
+    "journal/captures": "05_Process",
+    "work": "04_Work",
+    "collections": "01_Projects",
+    "collections/areas": "02_Areas",
+    "collections/attachments": "07_Attachments",
+    "knowledge": "03_Resources",
+    "knowledge/reviews": "06_Metadata/Weekly Reviews"
+  },
   "routines": ["morning", "weekly"]
 }