@xingular/harness 0.1.7 → 1.1.1

package/dist/sdk/core/fs.d.ts

@@ -0,0 +1,18 @@
+/** Writes through a temporary sibling file and renames it into place so readers never see a partial file. */
+export declare function atomicWrite(path: string, contents: string | Uint8Array): void;
+export declare function writeJson(path: string, value: unknown): void;
+/** `null` when the file does not exist; a file that exists but does not parse is an error. */
+export declare function readJson<T>(path: string): T | null;
+/** `readJson` for callers that treat an unreadable file like a missing one. */
+export declare function readJsonOr<T>(path: string, fallback: T): T;
+export declare function readText(path: string): string | null;
+export declare function appendLine(path: string, line: string): void;
+/** Accepts only IDs that are safe as a single path segment. */
+export declare function safeId(id: string): string;
+/** Accepts a relative path that stays inside its base directory. */
+export declare function safeRelative(path: string): string;
+/** Millisecond UTC timestamp, the format every record uses. */
+export declare function now(): string;
+export declare function newId(): string;
+export declare function isDir(path: string): boolean;
+export declare function isFile(path: string): boolean;

package/dist/sdk/core/fs.js

@@ -0,0 +1,106 @@
+import { randomUUID } from 'node:crypto';
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, normalize, sep } from 'node:path';
+import { HarnessError, invalid } from "./errors.js";
+/** Writes through a temporary sibling file and renames it into place so readers never see a partial file. */
+export function atomicWrite(path, contents) {
+    const parent = dirname(path);
+    mkdirSync(parent, { recursive: true });
+    const temporary = join(parent, `.${basename(path)}.${randomUUID()}.tmp`);
+    const file = openSync(temporary, 'w');
+    try {
+        writeSync(file, contents);
+        fsyncSync(file);
+    }
+    finally {
+        closeSync(file);
+    }
+    try {
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw error;
+    }
+}
+export function writeJson(path, value) {
+    atomicWrite(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+/** `null` when the file does not exist; a file that exists but does not parse is an error. */
+export function readJson(path) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new HarnessError('invalid_data', `Stored data could not be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** `readJson` for callers that treat an unreadable file like a missing one. */
+export function readJsonOr(path, fallback) {
+    try {
+        return readJson(path) ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export function readText(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function appendLine(path, line) {
+    let next = readText(path) ?? '';
+    if (next && !next.endsWith('\n'))
+        next += '\n';
+    atomicWrite(path, `${next}${line}\n`);
+}
+/** Accepts only IDs that are safe as a single path segment. */
+export function safeId(id) {
+    if (id.length > 0 && id.length <= 128 && /^[A-Za-z0-9_-]+$/.test(id))
+        return id;
+    throw invalid('Invalid identifier.');
+}
+/** Accepts a relative path that stays inside its base directory. */
+export function safeRelative(path) {
+    const parts = path.split(/[\\/]/);
+    if (!path || isAbsolute(path) || parts.some((part) => part === '' || part === '.' || part === '..')) {
+        throw invalid('Path must stay inside the working directory.');
+    }
+    return normalize(path).split(sep).join('/');
+}
+/** Millisecond UTC timestamp, the format every record uses. */
+export function now() {
+    return new Date().toISOString();
+}
+export function newId() {
+    return randomUUID();
+}
+export function isDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sdk/core/index.d.ts

@@ -0,0 +1,24 @@
+import { DatabaseSync, type SQLInputValue } from 'node:sqlite';
+/** Ordered, append-only migrations. Each runs in one transaction; the file is backed up first. */
+export declare const MIGRATIONS: readonly string[];
+export declare function dbPath(root: string): string;
+/** Runs `work` inside one transaction, rolling back if it throws. */
+export declare function transaction<T>(database: DatabaseSync, work: () => T): T;
+/**
+ * Applies pending migrations. The database file is copied first; if any migration fails, the
+ * copy is restored and the error is reported.
+ */
+export declare function migrate(path: string, migrations: readonly string[]): DatabaseSync;
+/** Runs `work` with the shared connection for this data root, opening and migrating it on first use. */
+export declare function withIndex<T>(root: string, work: (database: DatabaseSync) => T): T;
+/** Closes this data root's connection, if one is open. */
+export declare function closeIndex(root: string): void;
+/** Closes the connection and removes the index files; the next use rebuilds the schema. */
+export declare function deleteIndex(root: string): void;
+export type Param = SQLInputValue;
+export declare function all<T>(database: DatabaseSync, sql: string, ...params: Param[]): T[];
+export declare function run(database: DatabaseSync, sql: string, ...params: Param[]): void;
+/** Folder names under `<data root>/runs`. */
+export declare function runFolders(root: string): string[];
+/** Turns free text into an FTS5 query: each word becomes a quoted prefix term. */
+export declare function ftsQuery(query: string): string | null;

package/dist/sdk/core/index.js

@@ -0,0 +1,187 @@
+// Derived SQLite index at `<data root>/index.sqlite`: full-text search over every Wiki entry
+// (pages, facts, blocks, registry skills/prompts/rules), links, sources, revisions, run
+// metadata, and recall passages. Markdown, raw sources, revision manifests, registry files, and
+// run files stay canonical; the index can always be deleted and rebuilt from them.
+import { copyFileSync, existsSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { HarnessError } from "./errors.js";
+/** Index migration 4: recall, the searchable record of conversations and runs. */
+const RECALL_SCHEMA = `CREATE TABLE recall_runs (run_id TEXT PRIMARY KEY, passages INTEGER NOT NULL, status TEXT NOT NULL);
+     CREATE VIRTUAL TABLE recall_fts USING fts5(run_id UNINDEXED, seq UNINDEXED, role UNINDEXED, at UNINDEXED,
+        mode UNINDEXED, session_id UNINDEXED, project_id UNINDEXED, text, tokenize = 'unicode61 remove_diacritics 2');`;
+/** Ordered, append-only migrations. Each runs in one transaction; the file is backed up first. */
+export const MIGRATIONS = [
+    // 1: initial schema
+    `CREATE TABLE pages (scope TEXT NOT NULL, id TEXT NOT NULL, title TEXT NOT NULL, type TEXT NOT NULL,
+        updated_at TEXT, path TEXT NOT NULL, source_ids TEXT NOT NULL, PRIMARY KEY (scope, id));
+     CREATE VIRTUAL TABLE pages_fts USING fts5(scope UNINDEXED, id UNINDEXED, title, body, links, sources,
+        tokenize = 'unicode61 remove_diacritics 2');
+     CREATE TABLE links (scope TEXT NOT NULL, from_id TEXT NOT NULL, to_id TEXT NOT NULL, type TEXT NOT NULL);
+     CREATE INDEX links_to ON links (scope, to_id);
+     CREATE TABLE sources (scope TEXT NOT NULL, id TEXT NOT NULL, name TEXT NOT NULL, imported_at TEXT, version INTEGER,
+        PRIMARY KEY (scope, id));
+     CREATE TABLE revisions (scope TEXT NOT NULL, page_id TEXT NOT NULL, id TEXT NOT NULL, created_at TEXT, actor TEXT,
+        PRIMARY KEY (scope, id));
+     CREATE TABLE runs (id TEXT PRIMARY KEY, project_id TEXT, mode TEXT, harness TEXT, session_type TEXT,
+        session_id TEXT, status TEXT, started_at TEXT, ended_at TEXT);
+     CREATE INDEX runs_session ON runs (session_id, started_at);`,
+    // 2: accounts and token usage per run
+    `ALTER TABLE runs ADD COLUMN account_id TEXT;
+     CREATE INDEX runs_account ON runs (account_id, started_at);
+     CREATE TABLE usage (run_id TEXT PRIMARY KEY, account_id TEXT, harness TEXT, model TEXT, day TEXT NOT NULL,
+        input_tokens INTEGER NOT NULL DEFAULT 0, output_tokens INTEGER NOT NULL DEFAULT 0);
+     CREATE INDEX usage_account ON usage (account_id, day);`,
+    // 3: one global Wiki; entries replace per-scope pages and include facts and registry items
+    `DROP TABLE IF EXISTS pages_fts; DROP TABLE IF EXISTS pages; DROP TABLE IF EXISTS links;
+     DROP TABLE IF EXISTS sources; DROP TABLE IF EXISTS revisions;
+     CREATE TABLE entries (id TEXT PRIMARY KEY, kind TEXT NOT NULL, title TEXT NOT NULL, type TEXT, path TEXT NOT NULL,
+        namespace TEXT NOT NULL, file TEXT NOT NULL, updated_at TEXT, source_ids TEXT NOT NULL);
+     CREATE VIRTUAL TABLE entries_fts USING fts5(id UNINDEXED, kind UNINDEXED, namespace UNINDEXED, title, body, links, sources,
+        tokenize = 'unicode61 remove_diacritics 2');
+     CREATE TABLE links (from_id TEXT NOT NULL, to_id TEXT NOT NULL, type TEXT NOT NULL);
+     CREATE INDEX links_to ON links (to_id);
+     CREATE TABLE sources (id TEXT PRIMARY KEY, name TEXT NOT NULL, imported_at TEXT, version INTEGER);
+     CREATE TABLE revisions (entry_id TEXT NOT NULL, id TEXT PRIMARY KEY, created_at TEXT, actor TEXT);
+     CREATE INDEX revisions_entry ON revisions (entry_id, created_at);`,
+    RECALL_SCHEMA,
+    // 5: a per-run summary cache for the embedding application's analytics
+    `CREATE TABLE run_stats (run_id TEXT PRIMARY KEY, session_id TEXT NOT NULL, version INTEGER NOT NULL, stats TEXT NOT NULL);
+     CREATE INDEX run_stats_session ON run_stats (session_id, version);`,
+    // 6: the agent that replied, so one agent's runs can be read across its sessions
+    `ALTER TABLE runs ADD COLUMN agent_id TEXT;
+     CREATE INDEX runs_agent ON runs (agent_id, started_at);
+     CREATE INDEX runs_started ON runs (started_at);`,
+    // 7: the per-account usage table goes
+    'DROP TABLE IF EXISTS usage;'
+];
+const connections = new Map();
+export function dbPath(root) {
+    return join(root, 'index.sqlite');
+}
+function sqlError(error) {
+    return new HarnessError('index_error', error instanceof Error ? error.message : String(error), 'Settings → Projects and Storage → Repair index.');
+}
+function schemaVersion(database) {
+    database.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);');
+    const row = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+    const version = Number.parseInt(row?.value ?? '', 10);
+    return Number.isInteger(version) && version >= 0 ? version : 0;
+}
+/** Runs `work` inside one transaction, rolling back if it throws. */
+export function transaction(database, work) {
+    database.exec('BEGIN');
+    try {
+        const result = work();
+        database.exec('COMMIT');
+        return result;
+    }
+    catch (error) {
+        try {
+            database.exec('ROLLBACK');
+        }
+        catch {
+            // The transaction is already gone.
+        }
+        throw error;
+    }
+}
+/**
+ * Applies pending migrations. The database file is copied first; if any migration fails, the
+ * copy is restored and the error is reported.
+ */
+export function migrate(path, migrations) {
+    let database;
+    let current;
+    try {
+        database = new DatabaseSync(path);
+        current = schemaVersion(database);
+    }
+    catch (error) {
+        throw sqlError(error);
+    }
+    if (current >= migrations.length)
+        return database;
+    const backup = `${path.replace(/\.sqlite$/, '')}.sqlite.bak-v${current}`;
+    const hadFile = existsSync(path) && current > 0;
+    if (hadFile) {
+        try {
+            database.exec('PRAGMA wal_checkpoint(TRUNCATE);');
+        }
+        catch {
+            // A checkpoint that cannot run leaves the copy slightly behind, which a rebuild repairs.
+        }
+        copyFileSync(path, backup);
+    }
+    for (let index = current; index < migrations.length; index += 1) {
+        try {
+            transaction(database, () => {
+                database.exec(migrations[index]);
+                database.prepare("INSERT INTO meta (key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(String(index + 1));
+            });
+        }
+        catch (error) {
+            database.close();
+            if (hadFile)
+                copyFileSync(backup, path);
+            else
+                rmSync(path, { force: true });
+            throw new HarnessError('migration_failed', `Index migration ${index + 1} failed and the previous index was restored: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return database;
+}
+/** Runs `work` with the shared connection for this data root, opening and migrating it on first use. */
+export function withIndex(root, work) {
+    const path = dbPath(root);
+    let database = connections.get(path);
+    if (!database) {
+        database = migrate(path, MIGRATIONS);
+        try {
+            database.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;');
+        }
+        catch (error) {
+            database.close();
+            throw sqlError(error);
+        }
+        connections.set(path, database);
+    }
+    try {
+        return work(database);
+    }
+    catch (error) {
+        throw error instanceof HarnessError ? error : sqlError(error);
+    }
+}
+/** Closes this data root's connection, if one is open. */
+export function closeIndex(root) {
+    const path = dbPath(root);
+    connections.get(path)?.close();
+    connections.delete(path);
+}
+/** Closes the connection and removes the index files; the next use rebuilds the schema. */
+export function deleteIndex(root) {
+    closeIndex(root);
+    for (const suffix of ['', '-wal', '-shm'])
+        rmSync(`${dbPath(root)}${suffix}`, { force: true });
+}
+export function all(database, sql, ...params) {
+    return database.prepare(sql).all(...params);
+}
+export function run(database, sql, ...params) {
+    database.prepare(sql).run(...params);
+}
+/** Folder names under `<data root>/runs`. */
+export function runFolders(root) {
+    try {
+        return readdirSync(join(root, 'runs'));
+    }
+    catch {
+        return [];
+    }
+}
+/** Turns free text into an FTS5 query: each word becomes a quoted prefix term. */
+export function ftsQuery(query) {
+    const terms = query.split(/[^\p{Alphabetic}\p{N}]+/u).filter(Boolean).map((term) => `"${term.replaceAll('"', '')}"*`);
+    return terms.length ? terms.join(' ') : null;
+}

package/dist/sdk/core/path.d.ts

@@ -0,0 +1,7 @@
+export declare function searchPath(): string;
+/** The inherited PATH key, preserving Windows' existing capitalization. */
+export declare function pathVariableName(environment: NodeJS.ProcessEnv): string;
+/** A child environment with a directory prepended using the selected platform's PATH rules. */
+export declare function prependSearchPath(directory: string, existing: string, environment?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): Record<string, string>;
+/** The executable `name` resolves to: itself when absolute, else the first match on the search path. */
+export declare function findBinary(name: string): string | null;

package/dist/sdk/core/path.js

@@ -0,0 +1,79 @@
+// Where executables are found. POSIX desktop apps may start with a minimal PATH, so the login
+// shell's PATH is resolved once. Windows keeps the inherited PATH and its native separator.
+import { execFileSync } from 'node:child_process';
+import { accessSync, constants, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, extname, isAbsolute, join } from 'node:path';
+let resolved = null;
+export function searchPath() {
+    const platform = process.platform;
+    const pathKey = pathVariableName(process.env);
+    const inherited = process.env[pathKey] ?? '';
+    if (resolved?.platform === platform && resolved.inherited === inherited)
+        return resolved.path;
+    const separator = pathSeparator(platform);
+    const entries = [];
+    if (platform !== 'win32') {
+        try {
+            const output = execFileSync(process.env.SHELL || '/bin/zsh', ['-ilc', 'printf %s "$PATH"'], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
+            // Interactive shells may print banners; the PATH is the last line.
+            entries.push(...(output.split('\n').filter(Boolean).at(-1) ?? '').split(separator));
+        }
+        catch {
+            // The inherited PATH and the usual folders still apply.
+        }
+    }
+    entries.push(...inherited.split(separator));
+    if (platform !== 'win32') {
+        const home = homedir();
+        if (home)
+            entries.push(...['.local/bin', '.bun/bin', '.npm-global/bin', '.cargo/bin'].map((folder) => join(home, folder)));
+        entries.push('/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin');
+    }
+    const path = [...new Set(entries.filter(Boolean))].join(separator);
+    resolved = { platform, inherited, path };
+    return path;
+}
+/** The inherited PATH key, preserving Windows' existing capitalization. */
+export function pathVariableName(environment) {
+    return Object.keys(environment).find((name) => name.toLowerCase() === 'path') ?? 'PATH';
+}
+/** A child environment with a directory prepended using the selected platform's PATH rules. */
+export function prependSearchPath(directory, existing, environment = process.env, platform = process.platform) {
+    const values = [directory, existing].filter(Boolean);
+    return { [pathVariableName(environment)]: values.join(pathSeparator(platform)) };
+}
+function pathSeparator(platform) {
+    return platform === 'win32' ? ';' : delimiter;
+}
+function isExecutable(path) {
+    try {
+        accessSync(path, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** The executable `name` resolves to: itself when absolute, else the first match on the search path. */
+export function findBinary(name) {
+    const platform = process.platform;
+    const suffixes = platform === 'win32' && !extname(name)
+        ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean)
+        : [];
+    const names = [name, ...suffixes.map((suffix) => `${name}${suffix}`)];
+    if (isAbsolute(name)) {
+        for (const candidate of names)
+            if (isExecutable(candidate))
+                return candidate;
+        return null;
+    }
+    for (const directory of searchPath().split(pathSeparator(platform))) {
+        for (const candidateName of names) {
+            const candidate = join(directory, candidateName);
+            if (isExecutable(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}

package/dist/sdk/core/projects.d.ts

@@ -0,0 +1,18 @@
+export interface Project {
+    id: string;
+    name: string;
+    rootPath: string;
+    isGitRepository: boolean;
+    autoMaintenance: boolean;
+    createdAt: string;
+    slug: string;
+    /** `/projects/<slug>`: where this project's pages live in the Wiki. */
+    wikiNamespace: string;
+}
+/** Same rule as the Wiki's page slugs, kept here so `core` does not depend on `memory`. */
+export declare function slugify(text: string): string;
+export declare function uniqueSlug(name: string, taken: readonly string[]): string;
+export declare function listProjects(root: string): Project[];
+/** `listProjects` for callers that treat an unreadable registry like an empty one. */
+export declare function projectsOrNone(root: string): Project[];
+export declare function findProject(root: string, projectId: string): Project;

package/dist/sdk/core/projects.js

@@ -0,0 +1,67 @@
+// Projects: named working folders, each with a Wiki namespace (`/projects/<slug>`). The harness
+// reads `<data root>/projects.json`; the embedding application adds, renames, and removes them.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { notFound } from "./errors.js";
+import { readJson } from "./fs.js";
+import { newId } from "./fs.js";
+/** Same rule as the Wiki's page slugs, kept here so `core` does not depend on `memory`. */
+export function slugify(text) {
+    let value = '';
+    for (const character of text.toLowerCase()) {
+        if (/^[a-z0-9]$/.test(character))
+            value += character;
+        else if (value && !value.endsWith('-'))
+            value += '-';
+    }
+    value = value.replace(/^-+|-+$/g, '').slice(0, 60);
+    return value || `page-${newId().slice(0, 8)}`;
+}
+export function uniqueSlug(name, taken) {
+    const slug = slugify(name);
+    const base = slug.startsWith('page-') ? 'project' : slug;
+    let candidate = base;
+    for (let counter = 2; taken.includes(candidate); counter += 1)
+        candidate = `${base}-${counter}`;
+    return candidate;
+}
+function load(root) {
+    const records = readJson(join(root, 'projects.json')) ?? [];
+    // Records without a slug get a unique one derived from the name, in list order, so the result
+    // is the same on every read until the application persists it.
+    const taken = records.map((record) => record.slug ?? '').filter(Boolean);
+    for (const record of records) {
+        if (record.slug)
+            continue;
+        record.slug = uniqueSlug(record.name, taken);
+        taken.push(record.slug);
+    }
+    return records;
+}
+export function listProjects(root) {
+    return load(root).map((record) => ({
+        id: record.id,
+        name: record.name,
+        rootPath: record.rootPath,
+        isGitRepository: existsSync(join(record.rootPath, '.git')),
+        autoMaintenance: record.autoMaintenance,
+        createdAt: record.createdAt,
+        slug: record.slug,
+        wikiNamespace: `/projects/${record.slug}`
+    }));
+}
+/** `listProjects` for callers that treat an unreadable registry like an empty one. */
+export function projectsOrNone(root) {
+    try {
+        return listProjects(root);
+    }
+    catch {
+        return [];
+    }
+}
+export function findProject(root, projectId) {
+    const project = listProjects(root).find((entry) => entry.id === projectId);
+    if (!project)
+        throw notFound('Project');
+    return project;
+}

package/dist/sdk/core/secrets.d.ts

@@ -0,0 +1,2 @@
+/** Text that carries a credential marker is never written to the Wiki. */
+export declare function looksSecret(text: string): boolean;

package/dist/sdk/core/secrets.js

@@ -0,0 +1,5 @@
+const SECRET_MARKERS = ['-----BEGIN', 'sk-ant-', 'sk-proj-', 'ghp_', 'github_pat_', 'AKIA', 'xoxb-'];
+/** Text that carries a credential marker is never written to the Wiki. */
+export function looksSecret(text) {
+    return SECRET_MARKERS.some((marker) => text.includes(marker));
+}

package/dist/sdk/core/text.d.ts

@@ -0,0 +1,7 @@
+export declare function charCount(text: string): number;
+export declare function takeChars(text: string, count: number): string;
+/** Lines without their terminators; a final newline does not add an empty last line. */
+export declare function lines(text: string): string[];
+/** Orders file paths segment by segment, so a folder sorts before a sibling whose name extends it. */
+export declare function comparePaths(left: string, right: string): number;
+export declare const compareText: (left: string, right: string) => number;

package/dist/sdk/core/text.js

@@ -0,0 +1,40 @@
+// Text helpers that count Unicode characters, not UTF-16 units, so budgets and cuts agree across languages.
+export function charCount(text) {
+    let count = 0;
+    for (const _ of text)
+        count += 1;
+    return count;
+}
+export function takeChars(text, count) {
+    if (text.length <= count)
+        return text;
+    let taken = 0;
+    let end = 0;
+    for (const character of text) {
+        if (taken >= count)
+            break;
+        taken += 1;
+        end += character.length;
+    }
+    return text.slice(0, end);
+}
+/** Lines without their terminators; a final newline does not add an empty last line. */
+export function lines(text) {
+    if (!text)
+        return [];
+    const parts = text.split('\n');
+    if (parts[parts.length - 1] === '')
+        parts.pop();
+    return parts.map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line));
+}
+/** Orders file paths segment by segment, so a folder sorts before a sibling whose name extends it. */
+export function comparePaths(left, right) {
+    const a = left.split('/');
+    const b = right.split('/');
+    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
+        if (a[index] !== b[index])
+            return a[index] < b[index] ? -1 : 1;
+    }
+    return a.length - b.length;
+}
+export const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);

package/dist/sdk/doctor/checks.d.ts

@@ -0,0 +1,5 @@
+import type { Harness } from "../harness.js";
+import { type TerminalAssets } from "../terminal/terminals.js";
+import type { SecretStore } from "../accounts/secrets.js";
+import type { DoctorCheck, DoctorContext } from "./types.js";
+export declare function builtinChecks(harness: Harness, context: DoctorContext, secrets: SecretStore, assets?: TerminalAssets): Promise<DoctorCheck[]>;