sh3-core 0.19.6 → 0.20.2

package/dist/shards/activate.svelte.js

@@ -19,7 +19,7 @@
 import { sh3 } from '../sh3Runtime.svelte';
 import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb } from './registry';
 import { makeSh3Api } from '../sh3Api/headless';
-import { createDocumentHandle, getTenantId, getDocumentBackend } from '../documents';
+import { createDocumentHandle, getTenantId, getDocumentBackend, getActiveScopeId } from '../documents';
 import { fetchEnvState, putEnvState } from '../env/client';
 import { getEnvServerUrl } from '../env/index';
 import { apiFetch } from '../transport/apiFetch';
@@ -52,6 +52,13 @@ export const registeredShards = $state(new Map());
 const active = new Map();
 export const activeShards = $state(new Map());
 export const erroredShards = $state(new Map());
+let scopeResolver = null;
+/** Host-only. Register a callback that resolves whether the current scope
+ *  is a personal tenant or an active project. Wired by createShell after
+ *  bootstrap. Avoids circular dependencies with session-state. */
+export function __setScopeResolver(resolver) {
+    scopeResolver = resolver;
+}
 /**
  * Register (or re-register) a shard with the framework so it can later be
  * activated. Records the shard in `registeredShards` but does not run
@@ -146,7 +153,7 @@ export async function activateShard(id, opts) {
     };
     const hasBrowse = (_a = shard.manifest.permissions) === null || _a === void 0 ? void 0 : _a.includes(PERMISSION_DOCUMENTS_BROWSE);
     const browseCap = hasBrowse
-        ? createBrowseCapability(getTenantId(), getDocumentBackend(), {
+        ? createBrowseCapability(() => getTenantId(), getDocumentBackend(), {
             canRead: (_c = (_b = shard.manifest.permissions) === null || _b === void 0 ? void 0 : _b.includes(PERMISSION_DOCUMENTS_READ)) !== null && _c !== void 0 ? _c : false,
             canWrite: (_e = (_d = shard.manifest.permissions) === null || _d === void 0 ? void 0 : _d.includes(PERMISSION_DOCUMENTS_WRITE)) !== null && _e !== void 0 ? _e : false,
         })
@@ -172,7 +179,7 @@ export async function activateShard(id, opts) {
             }
         },
         documents: (options) => {
-            const handle = createDocumentHandle(getTenantId(), id, getDocumentBackend(), options);
+            const handle = createDocumentHandle(getActiveScopeId(), id, getDocumentBackend(), options);
             entry.cleanupFns.push(() => handle.dispose());
             return handle;
         },
@@ -220,6 +227,7 @@ export async function activateShard(id, opts) {
         get tenantId() {
             return getTenantId();
         },
+        getScope: () => { var _a; return (_a = scopeResolver === null || scopeResolver === void 0 ? void 0 : scopeResolver()) !== null && _a !== void 0 ? _a : 'tenant'; },
         zones: ((_f = shard.manifest.permissions) === null || _f === void 0 ? void 0 : _f.includes(PERMISSION_STATE_MANAGE))
             ? createZoneManager()
             : undefined,

package/dist/shards/types.d.ts

@@ -274,6 +274,13 @@ export interface ShardContext {
      * serialize into persistent storage.
      */
     tenantId: string;
+    /**
+     * Whether this shard is running in a 'tenant' (personal) or 'project'
+     * scope. Shards that need to scope their behavior differently per context
+     * can read this at any time — it is reactive through the session state.
+     * Returns 'tenant' when no project is active, 'project' otherwise.
+     */
+    getScope(): 'tenant' | 'project';
     /**
      * Cross-shard zone management API. Only present when the shard's
      * manifest declares the `'state:manage'` permission. Check with

package/dist/shell-shard/Terminal.svelte

@@ -28,6 +28,7 @@
   import BusySlot from './toolbar/slots/BusySlot.svelte';
   import { registerTerminalView, mintTerminalId, type TerminalHandle } from './terminal-registry';
   import { makeDispatchToTerminal } from './dispatch-to-terminal';
+  import type { BrowseCapability } from '../documents/browse';
 
   interface Props {
     shell: Sh3Api;
@@ -35,8 +36,9 @@
     userId: string;
     role: ShellRole;
     contributions: ContributionsApi;
+    docs?: BrowseCapability;
   }
-  let { shell, wsUrl, userId, role, contributions }: Props = $props();
+  let { shell, wsUrl, userId, role, contributions, docs }: Props = $props();
 
   // Per-mode buffer map. Each ModeBuffer bundles a Scrollback + history +
   // locked flag and is materialized lazily on first switch into that mode.
@@ -250,6 +252,7 @@
     session,
     sh3: shellWithModes,
     fs,
+    docs,
     cwd: () => session.cwd,
     busy: acquireBusy,
     customMode: (id: string) => contributedModes.find((d) => d.id === id) ?? null,

package/dist/shell-shard/Terminal.svelte.d.ts

@@ -1,12 +1,14 @@
 import { type Sh3Api } from './registry';
 import type { ShellRole } from './modes/types';
 import type { ContributionsApi } from '../contributions/types';
+import type { BrowseCapability } from '../documents/browse';
 interface Props {
     shell: Sh3Api;
     wsUrl: string;
     userId: string;
     role: ShellRole;
     contributions: ContributionsApi;
+    docs?: BrowseCapability;
 }
 declare const Terminal: import("svelte").Component<Props, {}, "">;
 type Terminal = ReturnType<typeof Terminal>;

package/dist/shell-shard/dispatch.d.ts

@@ -4,6 +4,7 @@ import type { TenantFsClient } from './tenant-fs-client';
 import type { ModeBuffer } from './mode-buffer.svelte';
 import type { ShellMode, ShellRole } from './modes/types';
 import type { ShellModeDescriptor } from './contract';
+import type { BrowseCapability } from '../documents/browse';
 export interface DispatchDeps {
     mode: () => ShellMode;
     /** Current shell role — used by invoke() role-gating. */
@@ -18,6 +19,7 @@ export interface DispatchDeps {
     session: SessionClient;
     sh3: Sh3Api;
     fs: TenantFsClient;
+    docs?: BrowseCapability;
     cwd: () => string;
     /**
      * Acquire a busy indicator. Returns a clear handle. Calling clear()

package/dist/shell-shard/dispatch.js

@@ -39,6 +39,7 @@ export function makeDispatch(deps) {
                 cwd: deps.cwd(),
                 dispatch,
                 fs: deps.fs,
+                docs: deps.docs,
             }, resolution.args);
             return;
         }
@@ -107,6 +108,7 @@ export function makeDispatch(deps) {
                     cwd: deps.cwd(),
                     dispatch,
                     fs: deps.fs,
+                    docs: deps.docs,
                 }, resolution.args);
             }
             catch (err) {

package/dist/shell-shard/manifest.js

@@ -1,5 +1,6 @@
 import { VERSION } from '../version';
 import { PERMISSION_STATE_MANAGE } from '../state/types';
+import { PERMISSION_DOCUMENTS_BROWSE, PERMISSION_DOCUMENTS_READ, PERMISSION_DOCUMENTS_WRITE, } from '../documents/types';
 export const manifest = {
     id: 'shell',
     label: 'Sh3',
@@ -9,5 +10,10 @@ export const manifest = {
     // and is statically mounted at sh3-server boot. The existing contract in
     // sh3-core/src/shards/types.ts documents that framework-shipped shards do
     // not use this field.
-    permissions: [PERMISSION_STATE_MANAGE],
+    permissions: [
+        PERMISSION_STATE_MANAGE,
+        PERMISSION_DOCUMENTS_BROWSE,
+        PERMISSION_DOCUMENTS_READ,
+        PERMISSION_DOCUMENTS_WRITE,
+    ],
 };

package/dist/shell-shard/shellShard.svelte.js

@@ -64,7 +64,7 @@ export const shellShard = {
                 const role = isAdmin() ? 'admin' : 'user';
                 const instance = mount(Terminal, {
                     target: container,
-                    props: { shell, wsUrl, userId, role, contributions: ctx.contributions },
+                    props: { shell, wsUrl, userId, role, contributions: ctx.contributions, docs: ctx.browse },
                 });
                 return {
                     unmount() {

package/dist/shell-shard/tenant-fs-client.js

@@ -8,6 +8,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _TenantFsClient_instances, _TenantFsClient_get;
+import { apiFetch } from '../transport/apiFetch';
 export class TenantFsClient {
     constructor(base = '') {
         _TenantFsClient_instances.add(this);
@@ -29,7 +30,7 @@ export class TenantFsClient {
 }
 _TenantFsClient_instances = new WeakSet(), _TenantFsClient_get = async function _TenantFsClient_get(route, path) {
     const url = `${this.base}${route}?path=${encodeURIComponent(path)}`;
-    const res = await fetch(url, { credentials: 'include' });
+    const res = await apiFetch(url);
     if (!res.ok) {
         let msg = `HTTP ${res.status}`;
         try {

package/dist/shell-shard/verbs/cat.d.ts

@@ -0,0 +1,2 @@
+import type { Verb } from '../../verbs/types';
+export declare const catVerb: Verb;

package/dist/shell-shard/verbs/cat.js

@@ -0,0 +1,35 @@
+import { parseScopePath } from './scope-parse';
+export const catVerb = {
+    name: 'cat',
+    summary: 'Print document content. Usage: cat <shardId>/<path>',
+    programmatic: true,
+    async run(ctx, args) {
+        const ts = Date.now();
+        if (!ctx.docs) {
+            ctx.scrollback.push({ kind: 'status', text: 'cat: document capability not available', level: 'error', ts });
+            return;
+        }
+        if (!args[0]) {
+            ctx.scrollback.push({ kind: 'status', text: 'usage: cat <shardId>/<path>', level: 'error', ts });
+            return;
+        }
+        const parsed = parseScopePath(args[0]);
+        if (!parsed || !parsed.path) {
+            ctx.scrollback.push({ kind: 'status', text: `cat: invalid path '${args[0]}'`, level: 'error', ts });
+            return;
+        }
+        if (!ctx.docs.readFrom) {
+            ctx.scrollback.push({ kind: 'status', text: 'cat: read permission not granted', level: 'error', ts });
+            return;
+        }
+        const content = await ctx.docs.readFrom(parsed.shardId, parsed.path);
+        if (content === null) {
+            ctx.scrollback.push({ kind: 'status', text: `cat: not found: ${args[0]}`, level: 'error', ts });
+            return;
+        }
+        const text = content instanceof ArrayBuffer
+            ? `<binary ${content.byteLength}b>`
+            : content;
+        ctx.scrollback.push({ kind: 'text', stream: 'stdout', chunks: [text], ts });
+    },
+};

package/dist/shell-shard/verbs/cat.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/verbs/cat.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from 'vitest';
+import { catVerb } from './cat';
+function makeDocs(overrides = {}) {
+    return Object.assign({ listDocuments: vi.fn(async () => []), listShards: vi.fn(async () => []), watchDocuments: vi.fn(() => () => { }), readFrom: vi.fn(async () => null) }, overrides);
+}
+function makeCtx(docs) {
+    const pushed = [];
+    const ctx = {
+        sh3: {},
+        scrollback: { push: (e) => pushed.push(e) },
+        session: {},
+        cwd: '/',
+        fs: {},
+        docs,
+        dispatch: async () => { },
+    };
+    return { ctx, pushed };
+}
+describe('cat verb', () => {
+    it('emits error when docs capability missing', async () => {
+        const { ctx, pushed } = makeCtx(undefined);
+        await catVerb.run(ctx, ['notes/draft.md']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+    });
+    it('emits usage error when no args', async () => {
+        const { ctx, pushed } = makeCtx(makeDocs());
+        await catVerb.run(ctx, []);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+        expect(err.text).toMatch(/usage/i);
+    });
+    it('outputs document content', async () => {
+        const docs = makeDocs({ readFrom: vi.fn(async () => 'hello world') });
+        const { ctx, pushed } = makeCtx(docs);
+        await catVerb.run(ctx, ['notes/draft.md']);
+        expect(docs.readFrom).toHaveBeenCalledWith('notes', 'draft.md');
+        const text = pushed.find((e) => e.kind === 'text');
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).toContain('hello world');
+    });
+    it('emits error when document not found', async () => {
+        const docs = makeDocs({ readFrom: vi.fn(async () => null) });
+        const { ctx, pushed } = makeCtx(docs);
+        await catVerb.run(ctx, ['notes/missing.md']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+        expect(err.text).toMatch(/not found/i);
+    });
+});

package/dist/shell-shard/verbs/index.js

@@ -12,6 +12,12 @@ import { viewsVerb, openVerb, closeVerb, popoutVerb, dockVerb } from './views';
 import { zonesVerb, zoneVerb } from './zones';
 import { envVerb } from './env';
 import { resetVerb } from './reset';
+import { lsVerb } from './ls';
+import { catVerb } from './cat';
+import { rmVerb } from './rm';
+import { mkdirVerb } from './mkdir';
+import { mvVerb } from './mv';
+import { xferVerb } from './xfer';
 export function registerV1Verbs(ctx) {
     ctx.registerVerb(makeHelpVerb());
     ctx.registerVerb(clearVerb);
@@ -29,4 +35,10 @@ export function registerV1Verbs(ctx) {
     ctx.registerVerb(zoneVerb);
     ctx.registerVerb(envVerb);
     ctx.registerVerb(resetVerb);
+    ctx.registerVerb(lsVerb);
+    ctx.registerVerb(catVerb);
+    ctx.registerVerb(rmVerb);
+    ctx.registerVerb(mkdirVerb);
+    ctx.registerVerb(mvVerb);
+    ctx.registerVerb(xferVerb);
 }

package/dist/shell-shard/verbs/ls.d.ts

@@ -0,0 +1,2 @@
+import type { Verb } from '../../verbs/types';
+export declare const lsVerb: Verb;

package/dist/shell-shard/verbs/ls.js

@@ -0,0 +1,48 @@
+import { parseScopePath } from './scope-parse';
+export const lsVerb = {
+    name: 'ls',
+    summary: 'List documents. Usage: ls | ls <shardId> | ls <shardId>/<prefix>',
+    programmatic: true,
+    async run(ctx, args) {
+        var _a, _b, _c;
+        const ts = Date.now();
+        if (!ctx.docs) {
+            ctx.scrollback.push({ kind: 'status', text: 'ls: document capability not available', level: 'error', ts });
+            return;
+        }
+        const all = await ctx.docs.listDocuments();
+        const arg = args[0];
+        if (!arg) {
+            // Group by shard, emit counts
+            const counts = new Map();
+            for (const doc of all) {
+                counts.set(doc.shardId, ((_a = counts.get(doc.shardId)) !== null && _a !== void 0 ? _a : 0) + 1);
+            }
+            if (counts.size === 0) {
+                ctx.scrollback.push({ kind: 'status', text: 'ls: no documents in active scope', level: 'info', ts });
+                return;
+            }
+            const lines = [...counts.entries()]
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([shard, count]) => `  ${shard.padEnd(24)} ${count} doc${count !== 1 ? 's' : ''}`);
+            ctx.scrollback.push({ kind: 'text', stream: 'stdout', chunks: [lines.join('\n') + '\n'], ts });
+            return;
+        }
+        const parsed = parseScopePath(arg);
+        const shardId = (_b = parsed === null || parsed === void 0 ? void 0 : parsed.shardId) !== null && _b !== void 0 ? _b : arg;
+        const prefix = (_c = parsed === null || parsed === void 0 ? void 0 : parsed.path) !== null && _c !== void 0 ? _c : '';
+        const docs = all.filter((d) => {
+            if (d.shardId !== shardId)
+                return false;
+            return prefix ? d.path.startsWith(prefix) : true;
+        });
+        if (docs.length === 0) {
+            ctx.scrollback.push({ kind: 'status', text: `ls: no documents in ${arg}`, level: 'info', ts });
+            return;
+        }
+        const lines = docs
+            .sort((a, b) => a.path.localeCompare(b.path))
+            .map((d) => `  ${d.path}`);
+        ctx.scrollback.push({ kind: 'text', stream: 'stdout', chunks: [lines.join('\n') + '\n'], ts });
+    },
+};

package/dist/shell-shard/verbs/ls.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/verbs/ls.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi } from 'vitest';
+import { lsVerb } from './ls';
+function makeDocs(overrides = {}) {
+    return Object.assign({ listDocuments: vi.fn(async () => []), listShards: vi.fn(async () => []), watchDocuments: vi.fn(() => () => { }) }, overrides);
+}
+function makeCtx(docs) {
+    const pushed = [];
+    const ctx = {
+        sh3: {},
+        scrollback: { push: (e) => pushed.push(e) },
+        session: {},
+        cwd: '/',
+        fs: {},
+        docs,
+        dispatch: async () => { },
+    };
+    return { ctx, pushed };
+}
+const sampleDocs = [
+    { shardId: 'notes', path: 'draft.md', size: 100, lastModified: 0 },
+    { shardId: 'notes', path: 'ideas/spark.md', size: 50, lastModified: 0 },
+    { shardId: 'design', path: 'spec.guml', size: 200, lastModified: 0 },
+];
+describe('ls verb', () => {
+    it('emits error when docs capability missing', async () => {
+        const { ctx, pushed } = makeCtx(undefined);
+        await lsVerb.run(ctx, []);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+    });
+    it('lists shards with doc counts when no args', async () => {
+        const docs = makeDocs({ listDocuments: vi.fn(async () => sampleDocs) });
+        const { ctx, pushed } = makeCtx(docs);
+        await lsVerb.run(ctx, []);
+        const text = pushed.find((e) => e.kind === 'text');
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).toMatch(/notes/);
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).toMatch(/design/);
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).toMatch(/2/); // notes has 2 docs
+    });
+    it('lists docs in a specific shard', async () => {
+        const docs = makeDocs({ listDocuments: vi.fn(async () => sampleDocs) });
+        const { ctx, pushed } = makeCtx(docs);
+        await lsVerb.run(ctx, ['notes']);
+        const text = pushed.find((e) => e.kind === 'text');
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).toMatch(/draft\.md/);
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).toMatch(/ideas\/spark\.md/);
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).not.toMatch(/spec\.guml/);
+    });
+    it('filters docs by prefix when path given', async () => {
+        const docs = makeDocs({ listDocuments: vi.fn(async () => sampleDocs) });
+        const { ctx, pushed } = makeCtx(docs);
+        await lsVerb.run(ctx, ['notes/ideas']);
+        const text = pushed.find((e) => e.kind === 'text');
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).toMatch(/spark\.md/);
+        expect(text === null || text === void 0 ? void 0 : text.chunks.join('')).not.toMatch(/draft\.md/);
+    });
+    it('emits a status when shard has no docs', async () => {
+        const docs = makeDocs({ listDocuments: vi.fn(async () => sampleDocs) });
+        const { ctx, pushed } = makeCtx(docs);
+        await lsVerb.run(ctx, ['empty-shard']);
+        const status = pushed.find((e) => e.kind === 'status' && e.level === 'info');
+        expect(status).toBeDefined();
+    });
+});

package/dist/shell-shard/verbs/mkdir.d.ts

@@ -0,0 +1,2 @@
+import type { Verb } from '../../verbs/types';
+export declare const mkdirVerb: Verb;

package/dist/shell-shard/verbs/mkdir.js

@@ -0,0 +1,30 @@
+import { parseScopePath } from './scope-parse';
+export const mkdirVerb = {
+    name: 'mkdir',
+    summary: 'Create a folder. Usage: mkdir <shardId>/<folder>',
+    programmatic: true,
+    async run(ctx, args) {
+        const ts = Date.now();
+        if (!ctx.docs) {
+            ctx.scrollback.push({ kind: 'status', text: 'mkdir: document capability not available', level: 'error', ts });
+            return;
+        }
+        if (!args[0]) {
+            ctx.scrollback.push({ kind: 'status', text: 'usage: mkdir <shardId>/<folder>', level: 'error', ts });
+            return;
+        }
+        if (!ctx.docs.writeTo) {
+            ctx.scrollback.push({ kind: 'status', text: 'mkdir: write permission not granted', level: 'error', ts });
+            return;
+        }
+        const parsed = parseScopePath(args[0]);
+        if (!parsed || !parsed.path) {
+            ctx.scrollback.push({ kind: 'status', text: `mkdir: invalid path '${args[0]}'`, level: 'error', ts });
+            return;
+        }
+        // Materialise the folder with a sentinel file; backends treat paths as flat.
+        const keepPath = parsed.path.replace(/\/$/, '') + '/.keep';
+        await ctx.docs.writeTo(parsed.shardId, keepPath, '');
+        ctx.scrollback.push({ kind: 'status', text: `mkdir: created ${args[0]}`, level: 'info', ts });
+    },
+};

package/dist/shell-shard/verbs/mkdir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/verbs/mkdir.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mkdirVerb } from './mkdir';
+function makeDocs(overrides = {}) {
+    return Object.assign({ listDocuments: vi.fn(async () => []), listShards: vi.fn(async () => []), watchDocuments: vi.fn(() => () => { }), writeTo: vi.fn(async () => { }) }, overrides);
+}
+function makeCtx(docs) {
+    const pushed = [];
+    const ctx = {
+        sh3: {},
+        scrollback: { push: (e) => pushed.push(e) },
+        session: {},
+        cwd: '/',
+        fs: {},
+        docs,
+        dispatch: async () => { },
+    };
+    return { ctx, pushed };
+}
+describe('mkdir verb', () => {
+    it('emits error when docs capability missing', async () => {
+        const { ctx, pushed } = makeCtx(undefined);
+        await mkdirVerb.run(ctx, ['notes/ideas']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+    });
+    it('emits usage error when no args', async () => {
+        const { ctx, pushed } = makeCtx(makeDocs());
+        await mkdirVerb.run(ctx, []);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err.text).toMatch(/usage/i);
+    });
+    it('creates a folder via writeTo', async () => {
+        const writeTo = vi.fn(async () => { });
+        const docs = makeDocs({ writeTo });
+        const { ctx, pushed } = makeCtx(docs);
+        await mkdirVerb.run(ctx, ['notes/ideas']);
+        expect(writeTo).toHaveBeenCalledWith('notes', 'ideas/.keep', '');
+        const ok = pushed.find((e) => e.kind === 'status' && e.level === 'info');
+        expect(ok).toBeDefined();
+    });
+    it('emits error when writeTo not available', async () => {
+        const docs = makeDocs({ writeTo: undefined });
+        const { ctx, pushed } = makeCtx(docs);
+        await mkdirVerb.run(ctx, ['notes/ideas']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+    });
+});

package/dist/shell-shard/verbs/mv.d.ts

@@ -0,0 +1,2 @@
+import type { Verb } from '../../verbs/types';
+export declare const mvVerb: Verb;

package/dist/shell-shard/verbs/mv.js

@@ -0,0 +1,33 @@
+import { parseScopePath } from './scope-parse';
+export const mvVerb = {
+    name: 'mv',
+    summary: 'Rename a document within a shard. Usage: mv <shardId>/<old> <shardId>/<new>',
+    programmatic: true,
+    async run(ctx, args) {
+        const ts = Date.now();
+        if (!ctx.docs) {
+            ctx.scrollback.push({ kind: 'status', text: 'mv: document capability not available', level: 'error', ts });
+            return;
+        }
+        if (args.length < 2) {
+            ctx.scrollback.push({ kind: 'status', text: 'usage: mv <shardId>/<old> <shardId>/<new>', level: 'error', ts });
+            return;
+        }
+        if (!ctx.docs.renameFrom) {
+            ctx.scrollback.push({ kind: 'status', text: 'mv: write permission not granted', level: 'error', ts });
+            return;
+        }
+        const src = parseScopePath(args[0]);
+        const dst = parseScopePath(args[1]);
+        if (!(src === null || src === void 0 ? void 0 : src.path) || !(dst === null || dst === void 0 ? void 0 : dst.path)) {
+            ctx.scrollback.push({ kind: 'status', text: 'mv: invalid path', level: 'error', ts });
+            return;
+        }
+        if (src.shardId !== dst.shardId) {
+            ctx.scrollback.push({ kind: 'status', text: 'mv: src and dst must be in the same shard (use xfer for cross-scope moves)', level: 'error', ts });
+            return;
+        }
+        await ctx.docs.renameFrom(src.shardId, src.path, dst.path);
+        ctx.scrollback.push({ kind: 'status', text: `mv: renamed ${args[0]} → ${args[1]}`, level: 'info', ts });
+    },
+};

package/dist/shell-shard/verbs/mv.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/verbs/mv.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mvVerb } from './mv';
+function makeDocs(overrides = {}) {
+    return Object.assign({ listDocuments: vi.fn(async () => []), listShards: vi.fn(async () => []), watchDocuments: vi.fn(() => () => { }), renameFrom: vi.fn(async () => { }) }, overrides);
+}
+function makeCtx(docs) {
+    const pushed = [];
+    const ctx = {
+        sh3: {},
+        scrollback: { push: (e) => pushed.push(e) },
+        session: {},
+        cwd: '/',
+        fs: {},
+        docs,
+        dispatch: async () => { },
+    };
+    return { ctx, pushed };
+}
+describe('mv verb', () => {
+    it('emits error when docs capability missing', async () => {
+        const { ctx, pushed } = makeCtx(undefined);
+        await mvVerb.run(ctx, ['notes/old.md', 'notes/new.md']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+    });
+    it('emits usage error when fewer than two args', async () => {
+        const { ctx, pushed } = makeCtx(makeDocs());
+        await mvVerb.run(ctx, ['notes/old.md']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err.text).toMatch(/usage/i);
+    });
+    it('renames a document within the same shard', async () => {
+        const renameFrom = vi.fn(async () => { });
+        const docs = makeDocs({ renameFrom });
+        const { ctx, pushed } = makeCtx(docs);
+        await mvVerb.run(ctx, ['notes/old.md', 'notes/new.md']);
+        expect(renameFrom).toHaveBeenCalledWith('notes', 'old.md', 'new.md');
+        const ok = pushed.find((e) => e.kind === 'status' && e.level === 'info');
+        expect(ok).toBeDefined();
+    });
+    it('emits error when src and dst are in different shards', async () => {
+        const { ctx, pushed } = makeCtx(makeDocs());
+        await mvVerb.run(ctx, ['notes/old.md', 'design/new.md']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+        expect(err.text).toMatch(/same shard/i);
+    });
+    it('emits error when renameFrom not available', async () => {
+        const docs = makeDocs({ renameFrom: undefined });
+        const { ctx, pushed } = makeCtx(docs);
+        await mvVerb.run(ctx, ['notes/old.md', 'notes/new.md']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+    });
+});

package/dist/shell-shard/verbs/rm.d.ts

@@ -0,0 +1,2 @@
+import type { Verb } from '../../verbs/types';
+export declare const rmVerb: Verb;

package/dist/shell-shard/verbs/rm.js

@@ -0,0 +1,28 @@
+import { parseScopePath } from './scope-parse';
+export const rmVerb = {
+    name: 'rm',
+    summary: 'Delete a document. Usage: rm <shardId>/<path>',
+    programmatic: true,
+    async run(ctx, args) {
+        const ts = Date.now();
+        if (!ctx.docs) {
+            ctx.scrollback.push({ kind: 'status', text: 'rm: document capability not available', level: 'error', ts });
+            return;
+        }
+        if (!args[0]) {
+            ctx.scrollback.push({ kind: 'status', text: 'usage: rm <shardId>/<path>', level: 'error', ts });
+            return;
+        }
+        if (!ctx.docs.deleteFrom) {
+            ctx.scrollback.push({ kind: 'status', text: 'rm: write permission not granted', level: 'error', ts });
+            return;
+        }
+        const parsed = parseScopePath(args[0]);
+        if (!parsed || !parsed.path) {
+            ctx.scrollback.push({ kind: 'status', text: `rm: invalid path '${args[0]}'`, level: 'error', ts });
+            return;
+        }
+        await ctx.docs.deleteFrom(parsed.shardId, parsed.path);
+        ctx.scrollback.push({ kind: 'status', text: `rm: deleted ${args[0]}`, level: 'info', ts });
+    },
+};

package/dist/shell-shard/verbs/rm.test.d.ts

@@ -0,0 +1 @@
+export {};