@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/memory/project-namespace.js

@@ -1,85 +1,2 @@
-// project-namespace.ts — the ONE-TIME derivation of a project store's
-// namespace, used by migration and the guidance producers that may initialize a
-// store. The runtime NEVER calls this: it reads the `namespace:` declaration on
-// a store's root INDEX.md and refuses to mount a store that has none, so a
-// store's identity cannot depend on cwd, git state, or discovery order after it
-// has already delivered documents.
-import { basename, dirname, relative, resolve, sep } from 'node:path';
-import { realpathOrSelf } from '../fs-utils.js';
-import { gitSync } from '../git.js';
-import { collapseTrailingIndex, normalizeDocName, slugCanonicalPath, validateNamespace } from './identity.js';
-/** Derive one project store's namespace: its existing root `name` first, else
- *  the git repository label plus the owner's path within its worktree, else the
- *  root guide's H1, else the owner basename. An existing root `name` that
- *  cannot be a namespace fails rather than falling through — a declared
- *  identity is never silently replaced. */
-export function deriveProjectNamespace(input) {
-    const ownerDir = resolve(input.ownerDir);
-    const rootName = input.rootFrontmatter?.['name'];
-    if (typeof rootName === 'string' && rootName.trim() !== '') {
-        // Lifted verbatim (only ordering prefixes and a trailing INDEX removed) —
-        // an already-authored identity is an address, not a label to re-slug.
-        const lifted = collapseTrailingIndex(normalizeDocName(rootName.trim()));
-        const check = validateNamespace(lifted);
-        if (!check.ok)
-            return { ok: false, reason: `root \`name: ${rootName.trim()}\` cannot become a namespace: ${check.reason}` };
-        return { ok: true, namespace: lifted, source: 'root-name' };
-    }
-    const fromGit = gitNamespace(ownerDir);
-    if (fromGit !== null)
-        return validated(fromGit, 'git-worktree');
-    const h1 = input.rootBody === undefined ? undefined : h1Title(input.rootBody);
-    if (h1 !== undefined)
-        return validated(slugCanonicalPath(h1), 'root-guide-h1');
-    return validated(slugCanonicalPath(basename(ownerDir) || ownerDir), 'owner-basename');
-}
-function validated(namespace, source) {
-    const check = validateNamespace(namespace);
-    return check.ok ? { ok: true, namespace, source } : { ok: false, reason: `derived namespace \`${namespace}\` is invalid: ${check.reason}` };
-}
-/** `<repo-label>/<owner path within its worktree>`, or `null` outside a git
- *  working tree. The label comes from `--git-common-dir`, which resolves a
- *  LINKED WORKTREE to the shared repo storage, so a canvas worktree checked out
- *  under a node-id path shares its main checkout's namespace. */
-function gitNamespace(ownerDir) {
-    const label = gitRepoLabel(ownerDir);
-    if (label === null)
-        return null;
-    const top = gitWorktreeRoot(ownerDir);
-    if (top === null)
-        return null;
-    // `--show-toplevel` resolves through symlinks (macOS /tmp -> /private/tmp);
-    // realpath both sides so a symlinked owner doesn't produce a `../..` suffix.
-    const rel = relative(realpathOrSelf(top), realpathOrSelf(ownerDir)).split(sep).join('/');
-    if (rel.startsWith('..'))
-        return null;
-    return rel === '' || rel === '.' ? slugCanonicalPath(label) : slugCanonicalPath(`${label}/${rel}`);
-}
-function gitRepoLabel(dir) {
-    const res = gitSync(['rev-parse', '--path-format=absolute', '--git-common-dir'], dir);
-    if (res.status !== 0)
-        return null;
-    const gitCommonDir = res.stdout.trim();
-    if (gitCommonDir === '')
-        return null;
-    return basename(dirname(gitCommonDir)) || null;
-}
-function gitWorktreeRoot(dir) {
-    const res = gitSync(['rev-parse', '--path-format=absolute', '--show-toplevel'], dir);
-    if (res.status !== 0)
-        return null;
-    const top = res.stdout.trim();
-    return top === '' ? null : resolve(top);
-}
-/** First Markdown H1 in a body, heading marker stripped. */
-function h1Title(body) {
-    for (const raw of body.split('\n')) {
-        const m = raw.match(/^#\s+(.+)$/);
-        if (m) {
-            const title = m[1].replace(/\s+/g, ' ').trim();
-            if (title !== '')
-                return title;
-        }
-    }
-    return undefined;
-}
+var g=Object.defineProperty;var n=(t,e)=>g(t,"name",{value:e,configurable:!0});import{basename as c,dirname as h,relative as k,resolve as m,sep as v}from"node:path";import{realpathOrSelf as f}from"../fs-utils.js";import{gitSync as d}from"../git.js";import{collapseTrailingIndex as b,normalizeDocName as $,slugCanonicalPath as i,validateNamespace as p}from"./identity.js";function R(t){const e=m(t.ownerDir),r=t.rootFrontmatter?.name;if(typeof r=="string"&&r.trim()!==""){const l=b($(r.trim())),u=p(l);return u.ok?{ok:!0,namespace:l,source:"root-name"}:{ok:!1,reason:`root \`name: ${r.trim()}\` cannot become a namespace: ${u.reason}`}}const o=N(e);if(o!==null)return a(o,"git-worktree");const s=t.rootBody===void 0?void 0:j(t.rootBody);return s!==void 0?a(i(s),"root-guide-h1"):a(i(c(e)||e),"owner-basename")}n(R,"deriveProjectNamespace");function a(t,e){const r=p(t);return r.ok?{ok:!0,namespace:t,source:e}:{ok:!1,reason:`derived namespace \`${t}\` is invalid: ${r.reason}`}}n(a,"validated");function N(t){const e=w(t);if(e===null)return null;const r=y(t);if(r===null)return null;const o=k(f(r),f(t)).split(v).join("/");return o.startsWith("..")?null:o===""||o==="."?i(e):i(`${e}/${o}`)}n(N,"gitNamespace");function w(t){const e=d(["rev-parse","--path-format=absolute","--git-common-dir"],t);if(e.status!==0)return null;const r=e.stdout.trim();return r===""?null:c(h(r))||null}n(w,"gitRepoLabel");function y(t){const e=d(["rev-parse","--path-format=absolute","--show-toplevel"],t);if(e.status!==0)return null;const r=e.stdout.trim();return r===""?null:m(r)}n(y,"gitWorktreeRoot");function j(t){for(const e of t.split(`
+`)){const r=e.match(/^#\s+(.+)$/);if(r){const o=r[1].replace(/\s+/g," ").trim();if(o!=="")return o}}}n(j,"h1Title");export{R as deriveProjectNamespace};

package/dist/core/memory/repository-association.js

@@ -1,129 +1 @@
-import { existsSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { gitSync } from '../git.js';
-import { realpathOrSelf } from '../fs-utils.js';
-import { CRTR_DIR_NAME } from '../../types.js';
-import { INDEX_SEGMENT, slugCanonicalSegment, validateNamespace } from './identity.js';
-const associationCache = new Map();
-const GIT_LOOKUP_TIMEOUT_MS = 5000;
-/** Normalize a POSIX-slash relative owner path into canonical segments. */
-export function normalizeOwnerRelativePath(relPosix) {
-    const normalizedSeparators = relPosix.replace(/\\/g, '/');
-    if (normalizedSeparators === '' || normalizedSeparators === '.')
-        return { ok: true, path: '' };
-    const rawSegments = normalizedSeparators.split('/');
-    for (const segment of rawSegments) {
-        if (segment === '' || segment === '.' || segment === '..') {
-            return { ok: false, reason: `owner path contains invalid segment \`${segment}\`` };
-        }
-    }
-    const segments = rawSegments.map(slugCanonicalSegment);
-    for (let i = 0; i < segments.length; i++) {
-        if (segments[i] === '') {
-            return { ok: false, reason: `directory \`${rawSegments[i]}\` normalizes to an empty name segment` };
-        }
-    }
-    const path = segments.join('/');
-    if (segments[segments.length - 1].toLowerCase() === INDEX_SEGMENT.toLowerCase()) {
-        return { ok: false, reason: `owner path ends in reserved segment \`${INDEX_SEGMENT}\`` };
-    }
-    const check = validateNamespace(path);
-    return check.ok ? { ok: true, path } : { ok: false, reason: check.reason };
-}
-/** Associate one physical project-store owner with its repository identity. */
-export function associateRepository(ownerDir) {
-    const owner = realpathOrSelf(resolve(ownerDir));
-    const cached = associationCache.get(owner);
-    if (cached !== undefined)
-        return { ok: true, association: cached };
-    const git = gitSync(['rev-parse', '--path-format=absolute', '--show-toplevel', '--git-common-dir'], owner, undefined, { timeoutMs: GIT_LOOKUP_TIMEOUT_MS });
-    if (git.status === 0 || git.timedOut === true || !/not a git repository/i.test(git.stderr)) {
-        if (git.timedOut === true) {
-            return failure('git-lookup-failed', owner, `git lookup timed out after ${GIT_LOOKUP_TIMEOUT_MS}ms`);
-        }
-        if (git.status !== 0) {
-            const detail = git.stderr.trim() || `git rev-parse exited with status ${git.status}`;
-            return failure('git-lookup-failed', owner, `git lookup failed: ${detail}`);
-        }
-        const lines = git.stdout.split(/\r?\n/);
-        const rootLine = lines[0]?.trim() ?? '';
-        const commonLine = lines[1]?.trim() ?? '';
-        if (rootLine === '' || commonLine === '') {
-            return failure('git-lookup-failed', owner, 'git lookup returned an empty repository root or common directory');
-        }
-        const repositoryRoot = realpathOrSelf(resolve(rootLine));
-        const repositoryKey = `git:${realpathOrSelf(resolve(commonLine))}`;
-        const rel = relative(repositoryRoot, owner).split(sep).join('/');
-        if (isAbsolute(rel) || rel === '..' || rel.startsWith('../')) {
-            return failure('owner-outside-root', owner, `owner ${owner} is outside repository root ${repositoryRoot}`, repositoryRoot);
-        }
-        const ownerPath = normalizeOwnerRelativePath(rel);
-        if (!ownerPath.ok)
-            return failure('owner-path-invalid', owner, ownerPath.reason, repositoryRoot);
-        return remember({
-            kind: 'git',
-            repositoryRoot,
-            repositoryKey,
-            ownerRelativePath: ownerPath.path,
-            declarationPath: join(repositoryRoot, CRTR_DIR_NAME, 'memory', 'INDEX.md'),
-        }, owner);
-    }
-    const repositoryRoot = nonGitRepositoryRoot(owner);
-    if (repositoryRoot === null)
-        return failure('no-project-root', owner, `no ancestor ${CRTR_DIR_NAME}/memory store found for ${owner}`);
-    const ownerPath = normalizeOwnerRelativePath(relative(repositoryRoot, owner).split(sep).join('/'));
-    if (!ownerPath.ok)
-        return failure('owner-path-invalid', owner, ownerPath.reason, repositoryRoot);
-    return remember({
-        kind: 'non-git',
-        repositoryRoot,
-        repositoryKey: `path:${repositoryRoot}`,
-        ownerRelativePath: ownerPath.path,
-        declarationPath: join(repositoryRoot, CRTR_DIR_NAME, 'memory', 'INDEX.md'),
-    }, owner);
-}
-/** Clear successful associations; failures are deliberately never cached. */
-export function resetRepositoryAssociationCache() {
-    associationCache.clear();
-}
-function remember(association, owner) {
-    associationCache.set(owner, association);
-    return { ok: true, association };
-}
-function failure(code, ownerDir, reason, repositoryRoot) {
-    return repositoryRoot === undefined
-        ? { ok: false, code, ownerDir, reason }
-        : { ok: false, code, ownerDir, repositoryRoot, reason };
-}
-function nonGitRepositoryRoot(owner) {
-    const home = realpathOrSelf(homedir());
-    const ownerIsUnderHome = isWithin(owner, home);
-    let dir = owner;
-    let outermost = null;
-    while (true) {
-        // The user's own .crouter/memory is a separate scope, never a project root.
-        if ((!ownerIsUnderHome || dir !== home) && hasProjectMemoryStore(dir))
-            outermost = dir;
-        if (ownerIsUnderHome && dir === home)
-            break;
-        const parent = dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return outermost;
-}
-function hasProjectMemoryStore(owner) {
-    const memory = join(owner, CRTR_DIR_NAME, 'memory');
-    try {
-        return existsSync(memory) && statSync(memory).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function isWithin(child, parent) {
-    const rel = relative(parent, child);
-    return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
-}
+var O=Object.defineProperty;var a=(o,t)=>O(o,"name",{value:t,configurable:!0});import{existsSync as j,statSync as C}from"node:fs";import{homedir as N}from"node:os";import{dirname as _,isAbsolute as $,join as d,relative as h,resolve as g,sep as y}from"node:path";import{gitSync as b}from"../git.js";import{realpathOrSelf as l}from"../fs-utils.js";import{CRTR_DIR_NAME as f}from"../../types.js";import{INDEX_SEGMENT as R,slugCanonicalSegment as x,validateNamespace as L}from"./identity.js";const k=new Map,S=5e3;function P(o){const t=o.replace(/\\/g,"/");if(t===""||t===".")return{ok:!0,path:""};const r=t.split("/");for(const i of r)if(i===""||i==="."||i==="..")return{ok:!1,reason:`owner path contains invalid segment \`${i}\``};const e=r.map(x);for(let i=0;i<e.length;i++)if(e[i]==="")return{ok:!1,reason:`directory \`${r[i]}\` normalizes to an empty name segment`};const n=e.join("/");if(e[e.length-1].toLowerCase()===R.toLowerCase())return{ok:!1,reason:`owner path ends in reserved segment \`${R}\``};const s=L(n);return s.ok?{ok:!0,path:n}:{ok:!1,reason:s.reason}}a(P,"normalizeOwnerRelativePath");function B(o){const t=l(g(o)),r=k.get(t);if(r!==void 0)return{ok:!0,association:r};const e=b(["rev-parse","--path-format=absolute","--show-toplevel","--git-common-dir"],t,void 0,{timeoutMs:S});if(e.status===0||e.timedOut===!0||!/not a git repository/i.test(e.stderr)){if(e.timedOut===!0)return u("git-lookup-failed",t,`git lookup timed out after ${S}ms`);if(e.status!==0){const M=e.stderr.trim()||`git rev-parse exited with status ${e.status}`;return u("git-lookup-failed",t,`git lookup failed: ${M}`)}const i=e.stdout.split(/\r?\n/),w=i[0]?.trim()??"",v=i[1]?.trim()??"";if(w===""||v==="")return u("git-lookup-failed",t,"git lookup returned an empty repository root or common directory");const m=l(g(w)),I=`git:${l(g(v))}`,c=h(m,t).split(y).join("/");if($(c)||c===".."||c.startsWith("../"))return u("owner-outside-root",t,`owner ${t} is outside repository root ${m}`,m);const p=P(c);return p.ok?E({kind:"git",repositoryRoot:m,repositoryKey:I,ownerRelativePath:p.path,declarationPath:d(m,f,"memory","INDEX.md")},t):u("owner-path-invalid",t,p.reason,m)}const n=T(t);if(n===null)return u("no-project-root",t,`no ancestor ${f}/memory store found for ${t}`);const s=P(h(n,t).split(y).join("/"));return s.ok?E({kind:"non-git",repositoryRoot:n,repositoryKey:`path:${n}`,ownerRelativePath:s.path,declarationPath:d(n,f,"memory","INDEX.md")},t):u("owner-path-invalid",t,s.reason,n)}a(B,"associateRepository");function F(){k.clear()}a(F,"resetRepositoryAssociationCache");function E(o,t){return k.set(t,o),{ok:!0,association:o}}a(E,"remember");function u(o,t,r,e){return e===void 0?{ok:!1,code:o,ownerDir:t,reason:r}:{ok:!1,code:o,ownerDir:t,repositoryRoot:e,reason:r}}a(u,"failure");function T(o){const t=l(N()),r=z(o,t);let e=o,n=null;for(;(!r||e!==t)&&D(e)&&(n=e),!(r&&e===t);){const s=_(e);if(s===e)break;e=s}return n}a(T,"nonGitRepositoryRoot");function D(o){const t=d(o,f,"memory");try{return j(t)&&C(t).isDirectory()}catch{return!1}}a(D,"hasProjectMemoryStore");function z(o,t){const r=h(t,o);return r===""||r!==".."&&!r.startsWith(`..${y}`)&&!$(r)}a(z,"isWithin");export{B as associateRepository,P as normalizeOwnerRelativePath,F as resetRepositoryAssociationCache};

package/dist/core/memory/tree.js

@@ -1,93 +1 @@
-// tree.ts — the ONE canonical directory model. A canonical name is a path in a
-// tree whose nodes merge across stores: a node holds the winning document at
-// that exact identity (with every physical candidate behind it) AND its
-// immediate children, so a directory that carries its own document is one row,
-// never a document plus a separate directory of the same name. Listing
-// generation, boot render, inline inventory, and lint all read structure from
-// here instead of scanning name prefixes.
-import { canonicalSegments, normalizeNameSegment } from './identity.js';
-/** The stored physical segments a document supplies as ordering keys for itself
- *  and its canonical ancestors. Both names are walked from the TAIL and stop at
- *  the first mismatch, because no canonical segment index addresses a physical
- *  one: a store's namespace has no physical counterpart at all, and an explicit
- *  `name:` detaches identity from the path entirely. */
-function physicalOrderSegments(doc) {
-    const canonical = canonicalSegments(doc.name);
-    const physical = canonicalSegments(doc.physicalRelativePath.replace(/\.md$/i, ''));
-    // The INDEX filename names its directory, not a segment of its own.
-    if (doc.representation === 'directory-index')
-        physical.pop();
-    const keys = [];
-    for (let i = canonical.length - 1, j = physical.length - 1; i >= 0 && j >= 0; i--, j--) {
-        const segment = physical[j];
-        if (normalizeNameSegment(segment) !== canonical[i])
-            break;
-        keys.push([canonical.slice(0, i + 1).join('/'), segment]);
-    }
-    return keys;
-}
-function hasMembers(node) {
-    return node.childDirectories.length > 0 || node.childDocuments.length > 0;
-}
-function compareNodes(a, b) {
-    return a.order.localeCompare(b.order) || a.name.localeCompare(b.name);
-}
-function asDocumentNode(node) {
-    if (node.document === null)
-        throw new Error(`memory tree: ${node.name} has neither a document nor members`);
-    return node;
-}
-function finalize(pending, order, index) {
-    const children = [...pending.children.values()]
-        .map((child) => finalize(child, order, index))
-        .sort(compareNodes);
-    const segments = canonicalSegments(pending.name);
-    const node = {
-        name: pending.name,
-        order: order.get(pending.name) ?? segments[segments.length - 1] ?? '',
-        document: pending.documents[0] ?? null,
-        documentCandidates: pending.documents,
-        childDirectories: children.filter(hasMembers),
-        childDocuments: children.filter((child) => !hasMembers(child)).map(asDocumentNode),
-    };
-    index.set(node.name, node);
-    return node;
-}
-/** Merge a precedence-ordered corpus into the canonical tree. Documents sharing
- *  one identity stay in source order behind that node, so its `document` is the
- *  address winner. */
-export function buildMemoryTree(docs) {
-    const root = { name: '', documents: [], children: new Map() };
-    const order = new Map();
-    for (const doc of docs) {
-        const segments = canonicalSegments(doc.name);
-        if (segments.length === 0)
-            continue;
-        let node = root;
-        for (let i = 0; i < segments.length; i++) {
-            const segment = segments[i];
-            let child = node.children.get(segment);
-            if (child === undefined) {
-                child = { name: segments.slice(0, i + 1).join('/'), documents: [], children: new Map() };
-                node.children.set(segment, child);
-            }
-            node = child;
-        }
-        node.documents.push(doc);
-        for (const [name, segment] of physicalOrderSegments(doc)) {
-            if (!order.has(name))
-                order.set(name, segment);
-        }
-    }
-    const index = new Map();
-    const rootNode = finalize(root, order, index);
-    const lookup = (name) => index.get(canonicalSegments(name).join('/')) ?? null;
-    return {
-        root: rootNode,
-        node: lookup,
-        isDirectory: (name) => {
-            const node = lookup(name);
-            return node !== null && hasMembers(node);
-        },
-    };
-}
+var g=Object.defineProperty;var s=(e,n)=>g(e,"name",{value:n,configurable:!0});import{canonicalSegments as a,normalizeNameSegment as y}from"./identity.js";function w(e){const n=a(e.name),o=a(e.physicalRelativePath.replace(/\.md$/i,""));e.representation==="directory-index"&&o.pop();const i=[];for(let c=n.length-1,r=o.length-1;c>=0&&r>=0;c--,r--){const t=o[r];if(y(t)!==n[c])break;i.push([n.slice(0,c+1).join("/"),t])}return i}s(w,"physicalOrderSegments");function f(e){return e.childDirectories.length>0||e.childDocuments.length>0}s(f,"hasMembers");function D(e,n){return e.order.localeCompare(n.order)||e.name.localeCompare(n.name)}s(D,"compareNodes");function M(e){if(e.document===null)throw new Error(`memory tree: ${e.name} has neither a document nor members`);return e}s(M,"asDocumentNode");function p(e,n,o){const i=[...e.children.values()].map(t=>p(t,n,o)).sort(D),c=a(e.name),r={name:e.name,order:n.get(e.name)??c[c.length-1]??"",document:e.documents[0]??null,documentCandidates:e.documents,childDirectories:i.filter(f),childDocuments:i.filter(t=>!f(t)).map(M)};return o.set(r.name,r),r}s(p,"finalize");function b(e){const n={name:"",documents:[],children:new Map},o=new Map;for(const t of e){const l=a(t.name);if(l.length===0)continue;let u=n;for(let m=0;m<l.length;m++){const d=l[m];let h=u.children.get(d);h===void 0&&(h={name:l.slice(0,m+1).join("/"),documents:[],children:new Map},u.children.set(d,h)),u=h}u.documents.push(t);for(const[m,d]of w(t))o.has(m)||o.set(m,d)}const i=new Map,c=p(n,o,i),r=s(t=>i.get(a(t).join("/"))??null,"lookup");return{root:c,node:r,isDirectory:s(t=>{const l=r(t);return l!==null&&f(l)},"isDirectory")}}s(b,"buildMemoryTree");export{b as buildMemoryTree};