npm - castle-web-cli - Versions diffs - 0.4.121 → 0.4.123 - Mend

castle-web-cli 0.4.121 → 0.4.123

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/dist/agent-prompts.js +6 -2
package/dist/diffText.d.ts +14 -0
package/dist/diffText.js +138 -0
package/dist/editorConfig.d.ts +6 -1
package/dist/editorConfig.js +20 -1
package/dist/ide.d.ts +2 -1
package/dist/ide.js +91 -2
package/dist/index.js +48 -2
package/dist/init.js +30 -0
package/dist/localPaths.d.ts +1 -0
package/dist/localPaths.js +5 -0
package/dist/shell/assets/index-CARLHafh.css +1 -0
package/dist/shell/assets/{index-UEwjXWKI.js → index-DWgt4KzC.js} +63 -63
package/dist/shell/index.html +2 -2
package/dist/versionStore.d.ts +54 -0
package/dist/versionStore.js +281 -0
package/dist/versions.d.ts +82 -0
package/dist/versions.js +446 -0
package/dist/vitePlugins.js +21 -8
package/kits/physics-2d/castle.json +1 -1
package/kits/physics-2d/editors/SingleEditor.jsx +43 -2
package/kits/physics-2d/editors/editorRegistry.jsx +34 -0
package/kits/physics-2d/main.jsx +11 -2
package/kits/physics-2d/package-lock.json +1 -1
package/package.json +1 -1
package/dist/shell/assets/index-BkJ87APM.css +0 -1

package/dist/shell/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
     <link rel="icon" type="image/png" sizes="32x32" href="/__castle/ide/favicon-32x32.png" />
     <link rel="icon" type="image/png" sizes="16x16" href="/__castle/ide/favicon-16x16.png" />
     <link rel="icon" href="/__castle/ide/favicon.ico" sizes="any" />
-    <script type="module" crossorigin src="/__castle/ide/assets/index-UEwjXWKI.js"></script>
-    <link rel="stylesheet" crossorigin href="/__castle/ide/assets/index-BkJ87APM.css">
+    <script type="module" crossorigin src="/__castle/ide/assets/index-DWgt4KzC.js"></script>
+    <link rel="stylesheet" crossorigin href="/__castle/ide/assets/index-CARLHafh.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/versionStore.d.ts ADDED Viewed

@@ -0,0 +1,54 @@
+export interface VersionChange {
+    /** Hash before this version, or null when the version added the file. */
+    before: string | null;
+    /** Hash after this version, or null when the version deleted the file. */
+    after: string | null;
+}
+export interface Version {
+    id: string;
+    parentId: string | null;
+    createdAt: string;
+    message: string;
+    /** Complete manifest at this version: deck-relative path -> content hash. */
+    files: Record<string, string>;
+    /** Only the paths this version touched. */
+    changes: Record<string, VersionChange>;
+}
+export declare function versionsRoot(projectDir: string): string;
+export declare function readHead(projectDir: string): string | null;
+export declare function writeHead(projectDir: string, id: string): void;
+export declare const VERSION_EXT = ".version";
+export declare function versionExists(projectDir: string, id: string): boolean;
+export declare function readVersion(projectDir: string, id: string): Version;
+export declare function writeVersion(projectDir: string, version: Version): void;
+export declare function hashBytes(content: Buffer): string;
+export declare function putBlob(projectDir: string, content: Buffer): string;
+export declare function getBlob(projectDir: string, hash: string): Buffer;
+export declare function blobCount(projectDir: string): number;
+/** Hash of the file as it is on disk right now, or null when it isn't there. */
+export declare function hashWorkingFile(projectDir: string, relPath: string): string | null;
+/** Hash the file and store its content, or null when it isn't there. */
+export declare function storeWorkingFile(projectDir: string, relPath: string): string | null;
+export declare function isIgnoredPath(relPath: string): boolean;
+/**
+ * Every tracked file in the deck, as sorted deck-relative POSIX paths. Files are
+ * bytes here -- nothing assumes text, and nothing looks at an extension.
+ */
+export declare function walkDeckFiles(projectDir: string): string[];
+/** Turn a path as typed on the command line into a deck-relative POSIX path. */
+export declare function toDeckRelative(projectDir: string, given: string): string | null;
+/**
+ * Versions from `fromId` back along `parentId`, newest first. Follows the stored
+ * parent links rather than any list order, so a forked history walks correctly.
+ */
+export declare function versionChain(projectDir: string, fromId: string): Version[];
+export declare function readAllVersions(projectDir: string): Version[];
+/**
+ * The chain of children from `fromId`, nearest first, following the most
+ * recently created child at each step. One chain, not a subtree: a fork picks a
+ * side, deterministically, rather than fanning out.
+ */
+export declare function forwardChain(projectDir: string, fromId: string): Version[];
+/** Manifest of a version, or an empty one for the very first version. */
+export declare function parentManifest(projectDir: string, parentId: string | null): Record<string, string>;
+export declare function diffManifests(before: Record<string, string>, after: Record<string, string>, onlyPaths?: string[]): Record<string, VersionChange>;

package/dist/versionStore.js ADDED Viewed

@@ -0,0 +1,281 @@
+// The on-disk store behind save-version / list-versions / restore-version.
+//
+// Everything lives under the deck at `.castle/versions/`:
+//   data/<sha256>        gzipped file content, addressed by the hash of the RAW
+//                        bytes -- so identical content across files or versions
+//                        is stored once.
+//   versions/<id>.version  one version object.
+//   head                 id of the latest version.
+//
+// `.version` rather than `.json` so a version is a real file at a real path
+// with a type of its own: the deck's `editor.fileTypes` routing can hand it an
+// editor later without a synthetic path or an open-by-id panel. `.castle` is
+// ignored, so versions never version themselves.
+//
+// A version carries a COMPLETE manifest (`files`) plus the paths it touched
+// (`changes`). `changes` is derivable from the parent's manifest, but is stored
+// explicitly so a restore works without the parent object being present -- which
+// is what lets only the last N versions be materialized locally later.
+//
+// Two rules keep branching open even though this build has none: a version
+// always records its `parentId`, and a version is only ever identified by that
+// opaque id -- never by a position in a list, and nothing here assumes the
+// history is linear.
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as zlib from 'zlib';
+import { toPosixPath } from './localPaths.js';
+// Not tracked: dependencies, build output, our own store, git, and imported
+// decks (whose files belong to the deck that published them).
+const IGNORED_SEGMENTS = new Set(['node_modules', '.castle', '.git', 'dist', 'imports']);
+export function versionsRoot(projectDir) {
+    return path.join(projectDir, '.castle', 'versions');
+}
+function dataDir(projectDir) {
+    return path.join(versionsRoot(projectDir), 'data');
+}
+function versionsDir(projectDir) {
+    return path.join(versionsRoot(projectDir), 'versions');
+}
+function headPath(projectDir) {
+    return path.join(versionsRoot(projectDir), 'head');
+}
+export function readHead(projectDir) {
+    try {
+        const id = fs.readFileSync(headPath(projectDir), 'utf-8').trim();
+        return id || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeHead(projectDir, id) {
+    fs.mkdirSync(versionsRoot(projectDir), { recursive: true });
+    fs.writeFileSync(headPath(projectDir), id + '\n', 'utf-8');
+}
+// A version's own file. Its extension is part of the format, not an internal
+// detail: a deck can route `.version` to an editor of its own.
+export const VERSION_EXT = '.version';
+function versionFile(projectDir, id) {
+    return path.join(versionsDir(projectDir), `${id}${VERSION_EXT}`);
+}
+export function versionExists(projectDir, id) {
+    return fs.existsSync(versionFile(projectDir, id));
+}
+export function readVersion(projectDir, id) {
+    const file = versionFile(projectDir, id);
+    if (!fs.existsSync(file))
+        throw new Error(`No such version: ${id}`);
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+}
+// Blobs and version files are write-once: a blob is named by its own content
+// and a version id is never reused, so nothing here is ever rewritten. Marking
+// them read-only AT CREATION therefore costs nothing and is never unlocked --
+// no race, no unlock window. `head` stays writable, being the one mutable thing
+// in the store, and the directories stay writable so new files can be created
+// and a future gc can delete.
+const READ_ONLY = 0o444;
+function writeOnce(file, content) {
+    fs.writeFileSync(file, content);
+    fs.chmodSync(file, READ_ONLY);
+}
+export function writeVersion(projectDir, version) {
+    fs.mkdirSync(versionsDir(projectDir), { recursive: true });
+    writeOnce(versionFile(projectDir, version.id), JSON.stringify(version, null, 2) + '\n');
+}
+export function hashBytes(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+// Content-addressed, so an identical blob is written once and every later
+// reference is free.
+export function putBlob(projectDir, content) {
+    const hash = hashBytes(content);
+    const blob = path.join(dataDir(projectDir), hash);
+    if (!fs.existsSync(blob)) {
+        fs.mkdirSync(dataDir(projectDir), { recursive: true });
+        writeOnce(blob, zlib.gzipSync(content));
+    }
+    return hash;
+}
+// Read is where corruption surfaces, so the hash is checked here: the content is
+// addressed BY its hash, so re-hashing what came back is the whole verification.
+// A restore that would write the wrong bytes over someone's file stops instead.
+export function getBlob(projectDir, hash) {
+    const blob = path.join(dataDir(projectDir), hash);
+    if (!fs.existsSync(blob))
+        throw new Error(`Missing stored content ${hash}`);
+    let content;
+    try {
+        content = zlib.gunzipSync(fs.readFileSync(blob));
+    }
+    catch (e) {
+        throw new Error(`Stored content ${hash} is unreadable: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const actual = hashBytes(content);
+    if (actual !== hash) {
+        throw new Error(`Stored content ${hash} is corrupt (hashes as ${actual}).`);
+    }
+    return content;
+}
+export function blobCount(projectDir) {
+    try {
+        return fs.readdirSync(dataDir(projectDir)).length;
+    }
+    catch {
+        return 0;
+    }
+}
+// Bytes of a tracked file, or null when there is no file there -- which is how
+// a deletion reads to everything above.
+function readWorkingFile(projectDir, relPath) {
+    const abs = path.join(projectDir, relPath);
+    try {
+        if (!fs.statSync(abs).isFile())
+            return null;
+        return fs.readFileSync(abs);
+    }
+    catch {
+        return null;
+    }
+}
+/** Hash of the file as it is on disk right now, or null when it isn't there. */
+export function hashWorkingFile(projectDir, relPath) {
+    const content = readWorkingFile(projectDir, relPath);
+    return content ? hashBytes(content) : null;
+}
+/** Hash the file and store its content, or null when it isn't there. */
+export function storeWorkingFile(projectDir, relPath) {
+    const content = readWorkingFile(projectDir, relPath);
+    return content ? putBlob(projectDir, content) : null;
+}
+export function isIgnoredPath(relPath) {
+    return relPath.split('/').some((segment) => IGNORED_SEGMENTS.has(segment));
+}
+/**
+ * Every tracked file in the deck, as sorted deck-relative POSIX paths. Files are
+ * bytes here -- nothing assumes text, and nothing looks at an extension.
+ */
+export function walkDeckFiles(projectDir) {
+    const out = [];
+    const walk = (absDir, relDir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(absDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
+            if (isIgnoredPath(rel))
+                continue;
+            // Symlinks are followed no further than their own entry: a link is not a
+            // file whose bytes we can restore.
+            if (entry.isDirectory())
+                walk(path.join(absDir, entry.name), rel);
+            else if (entry.isFile())
+                out.push(rel);
+        }
+    };
+    walk(projectDir, '');
+    return out.sort();
+}
+/** Turn a path as typed on the command line into a deck-relative POSIX path. */
+export function toDeckRelative(projectDir, given) {
+    const abs = path.resolve(given);
+    const rel = path.relative(projectDir, abs);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+        return null;
+    return toPosixPath(rel);
+}
+/**
+ * Versions from `fromId` back along `parentId`, newest first. Follows the stored
+ * parent links rather than any list order, so a forked history walks correctly.
+ */
+export function versionChain(projectDir, fromId) {
+    const chain = [];
+    const seen = new Set();
+    let cursor = fromId;
+    while (cursor) {
+        if (seen.has(cursor))
+            throw new Error(`Version history loops at ${cursor}`);
+        seen.add(cursor);
+        const version = readVersion(projectDir, cursor);
+        chain.push(version);
+        cursor = version.parentId;
+    }
+    return chain;
+}
+// Every version in the store. Only `parentId` is stored, so finding a version's
+// children means reading them all -- fine at this scale, and a child index is a
+// later optimisation if it ever stops being. A file that won't parse is skipped
+// rather than taking the whole listing down with it.
+export function readAllVersions(projectDir) {
+    let names;
+    try {
+        names = fs.readdirSync(versionsDir(projectDir));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        if (!name.endsWith(VERSION_EXT))
+            continue;
+        try {
+            out.push(readVersion(projectDir, name.slice(0, -VERSION_EXT.length)));
+        }
+        catch {
+            continue;
+        }
+    }
+    return out;
+}
+/**
+ * The chain of children from `fromId`, nearest first, following the most
+ * recently created child at each step. One chain, not a subtree: a fork picks a
+ * side, deterministically, rather than fanning out.
+ */
+export function forwardChain(projectDir, fromId) {
+    const childrenOf = new Map();
+    for (const version of readAllVersions(projectDir)) {
+        if (!version.parentId)
+            continue;
+        const siblings = childrenOf.get(version.parentId);
+        if (siblings)
+            siblings.push(version);
+        else
+            childrenOf.set(version.parentId, [version]);
+    }
+    const chain = [];
+    const seen = new Set([fromId]);
+    let cursor = fromId;
+    for (;;) {
+        const children = childrenOf.get(cursor);
+        if (!children || children.length === 0)
+            return chain;
+        // Newest wins; the id breaks a same-timestamp tie so the walk is stable.
+        const next = [...children].sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id))[0];
+        if (seen.has(next.id))
+            return chain;
+        seen.add(next.id);
+        chain.push(next);
+        cursor = next.id;
+    }
+}
+/** Manifest of a version, or an empty one for the very first version. */
+export function parentManifest(projectDir, parentId) {
+    return parentId ? readVersion(projectDir, parentId).files : {};
+}
+export function diffManifests(before, after, onlyPaths) {
+    const paths = onlyPaths ?? [...new Set([...Object.keys(before), ...Object.keys(after)])];
+    const changes = {};
+    for (const p of paths.sort()) {
+        const from = before[p] ?? null;
+        const to = after[p] ?? null;
+        if (from !== to)
+            changes[p] = { before: from, after: to };
+    }
+    return changes;
+}

package/dist/versions.d.ts ADDED Viewed

@@ -0,0 +1,82 @@
+import * as store from './versionStore.js';
+export interface SaveVersionOptions {
+    message?: string;
+    /** Paths as typed on the command line; empty means the whole tree. */
+    paths?: string[];
+}
+export interface SaveOutcome {
+    /** The version written, or null when nothing had changed. */
+    version: store.Version | null;
+    /** True when paths were named, so unselected files stayed dirty. */
+    partial: boolean;
+}
+export declare function createVersion(projectDir: string, opts?: SaveVersionOptions): SaveOutcome;
+export declare function saveVersion(dir: string, opts?: SaveVersionOptions): void;
+export type ChangeKind = 'added' | 'changed' | 'deleted';
+/** One version as a list wants it: no manifest, changes already classified. */
+export interface VersionSummary {
+    id: string;
+    parentId: string | null;
+    createdAt: string;
+    message: string;
+    changes: {
+        path: string;
+        kind: ChangeKind;
+    }[];
+    /** True for versions after the one being listed from -- see versionSummaries. */
+    later: boolean;
+}
+/**
+ * What has changed on disk since head, in the same shape a version's `changes`
+ * takes. Hashes the tree WITHOUT storing anything -- asking what is outstanding
+ * must not write to the store.
+ */
+export declare function pendingChanges(projectDir: string): {
+    path: string;
+    kind: ChangeKind;
+}[];
+/**
+ * The deck's history newest first. From head (no `fromId`): the chain forward
+ * from head -- marked `later` -- then head, then its ancestors. From a named
+ * version: that version and its ancestors, as it has always been.
+ *
+ * The forward walk is why a restore no longer makes the versions after it
+ * vanish from the panel and from `list-versions`. It follows one chain of
+ * children, newest child at each step. After a save there is nothing to follow,
+ * because the new version is a leaf, so the forward rows drop away on their own
+ * -- the abandoned versions are still on disk, just no longer reachable forward
+ * from head.
+ *
+ * Naming a version asks a different question -- how did THIS version come to be
+ * -- so that form stays a walk back and is unchanged.
+ */
+export declare function versionSummaries(projectDir: string, fromId?: string): VersionSummary[];
+export declare function listVersions(dir: string, version?: string): void;
+/**
+ * What one version changed, as diffs of the CHANGED FILES ONLY -- built from the
+ * two blobs each entry in `changes` already names, so nothing new is stored and
+ * the whole tree is never read. The CLI counterpart of the panel's row
+ * expansion, for an agent working out what a change did.
+ */
+export declare function showVersion(dir: string, versionId: string): void;
+export declare class UnsavedChanges extends Error {
+    readonly paths: string[];
+    constructor(paths: string[]);
+}
+export declare class NotOnThisLine extends Error {
+    constructor(targetId: string, head: string);
+}
+export interface RestoreOutcome {
+    /** True when head was already the target, so nothing was looked at. */
+    alreadyThere: boolean;
+    /** Path -> hash written, null meaning the file was deleted. */
+    applied: [string, string | null][];
+    /** How many versions the head move took off the chain. */
+    offChain: number;
+}
+export declare function applyVersionRestore(projectDir: string, targetId: string, opts?: {
+    force?: boolean;
+}): RestoreOutcome;
+export declare function restoreVersion(dir: string, targetId: string, opts?: {
+    force?: boolean;
+}): void;