@openvulcan/dsh-vulcancode 0.0.0-stage → 0.4.0

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/page.d.ts

@@ -0,0 +1,132 @@
+/**
+ * What the memory page asks of the Host (`markdown_memory_services.rs`): the overview of one host
+ * project, writes as the user, whole-file editing, registry changes, settings, and export/import.
+ * Host projects are dsh workspaces; export packages travel through the browser as base64, since the
+ * page may run on another machine than the Host.
+ */
+import type { Workspace } from '@deepseek-ai/dsh-workspace';
+import { type ImportPreview, type ImportReport } from './markdown/package.js';
+import { type MemoryScope } from './markdown/scope.js';
+import type { MarkdownMemoryStore } from './markdown/store.js';
+import { saveSettings, type InjectionBudget, type MemorySettings } from './settings.js';
+/** A dsh workspace as the memory page sees it. */
+export interface HostProject {
+    /** Host project id derived from the root, the same id sessions in it use. */
+    readonly id: string;
+    readonly path: string;
+    readonly title: string;
+}
+export interface MemorySettingsView extends MemorySettings {
+    readonly defaultBudget: InjectionBudget;
+    readonly maxPartTokens: number;
+    readonly warningPercent: number;
+}
+export interface NodeViewModel {
+    readonly id: string;
+    readonly level: number;
+    readonly path: readonly string[];
+    readonly section: string | null;
+    readonly revision: string;
+    readonly body: string;
+    readonly created: string | null;
+    readonly updated: string | null;
+    readonly session: string | null;
+    /** `ai` or `user`; `null` for nodes never written through memory. */
+    readonly source: string | null;
+    readonly descendants: number;
+}
+export interface ProjectView {
+    readonly id: string;
+    readonly name: string;
+    readonly hostProjectIds: readonly string[];
+    readonly paths: readonly string[];
+    readonly memoryEnabled: boolean;
+    /** No recorded path exists any more. */
+    readonly orphaned: boolean;
+    readonly updated: string;
+}
+export interface MemoryOverview {
+    readonly settings: MemorySettingsView;
+    readonly user: readonly NodeViewModel[];
+    readonly space: readonly NodeViewModel[];
+    readonly project: readonly NodeViewModel[];
+    /** Memory project shown in the project tab. */
+    readonly memoryProjectId: string | null;
+    /** Memory project bound to the host project. */
+    readonly boundMemoryProjectId: string | null;
+    readonly hostProjectId: string | null;
+    /** Orphans suggested for linking; empty once bound or dismissed. */
+    readonly orphanCandidates: readonly {
+        readonly memoryProjectId: string;
+        readonly reasons: readonly string[];
+    }[];
+    readonly projects: readonly ProjectView[];
+    readonly usage: readonly {
+        readonly part: string;
+        readonly tokens: number;
+        readonly budget: number;
+        readonly omitted: readonly string[];
+    }[];
+    readonly presetSections: readonly {
+        readonly scope: MemoryScope;
+        readonly key: string;
+        readonly title: string;
+    }[];
+    /** Every dsh workspace, for the project selector; VulcanCode's page reads them from its own store. */
+    readonly hostProjects: readonly HostProject[];
+}
+/** One registry change requested by the page. */
+export type ProjectAction = {
+    readonly action: 'link';
+    readonly projectId: string;
+    readonly memoryProjectId: string;
+} | {
+    readonly action: 'create';
+    readonly projectId: string;
+} | {
+    readonly action: 'ignore';
+    readonly projectId: string;
+} | {
+    readonly action: 'set_enabled';
+    readonly memoryProjectId: string;
+    readonly enabled: boolean;
+} | {
+    readonly action: 'rename';
+    readonly memoryProjectId: string;
+    readonly name: string;
+};
+export declare function hostProjectOf(workspace: Pick<Workspace, 'path' | 'title'>): HostProject;
+/** The host project of a page request; an unknown id is refused, as VulcanCode refuses it. */
+export declare function resolveHost(hosts: readonly HostProject[], projectId: string | undefined): HostProject | undefined;
+export declare function settingsView(settings: MemorySettings): MemorySettingsView;
+export declare function loadOverview(store: MarkdownMemoryStore, hosts: readonly HostProject[], host: HostProject | undefined, memoryProjectId: string | undefined): MemoryOverview;
+/** Write as the user; the first project write may create and bind a memory project. Disabled projects stay editable. */
+export declare function writeAsUser(store: MarkdownMemoryStore, hosts: readonly HostProject[], host: HostProject | undefined, memoryProjectId: string | undefined, operations: unknown): MemoryOverview;
+export declare function applyProjectAction(store: MarkdownMemoryStore, host: HostProject | undefined, action: ProjectAction): ProjectView[];
+/** The host project a registry action names; only link, create and ignore name one. */
+export declare function actionHostId(action: ProjectAction): string | undefined;
+export declare function readFile(store: MarkdownMemoryStore, scope: MemoryScope, memoryProjectId: string | undefined): {
+    path: string;
+    text: string;
+};
+export declare function replaceFile(store: MarkdownMemoryStore, scope: MemoryScope, memoryProjectId: string | undefined, expected: string, text: string): {
+    path: string;
+    text: string;
+};
+/** An object holding only the listed fields. */
+export declare function fields(value: unknown, allowed: readonly string[]): Record<string, unknown>;
+export declare function text(input: Record<string, unknown>, field: string): string;
+export declare function optionalText(input: Record<string, unknown>, field: string): string | undefined;
+export declare function scopeParam(value: unknown): MemoryScope;
+export declare function parseProjectAction(value: unknown): ProjectAction;
+export declare function parseSettingsSave(value: unknown): MemorySettings;
+/** Archive bytes sent by the page as base64. */
+export declare function archiveBytes(input: Record<string, unknown>): Uint8Array;
+export declare function exportRequest(store: MarkdownMemoryStore, value: unknown): {
+    fileName: string;
+    archive: string;
+    sha256: string;
+};
+export declare function previewRequest(store: MarkdownMemoryStore, value: unknown): ImportPreview;
+export declare function importRequest(store: MarkdownMemoryStore, value: unknown): ImportReport;
+export { saveSettings };

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/page.js

@@ -0,0 +1,235 @@
+/**
+ * What the memory page asks of the Host (`markdown_memory_services.rs`): the overview of one host
+ * project, writes as the user, whole-file editing, registry changes, settings, and export/import.
+ * Host projects are dsh workspaces; export packages travel through the browser as base64, since the
+ * page may run on another machine than the Host.
+ */
+import { existsSync } from 'node:fs';
+import { MAX_PART_TOKENS, BUDGET_WARNING_PERCENT } from './markdown/constants.js';
+import { MemoryError } from './markdown/errors.js';
+import { parseWriteOperation, writeMemory } from './markdown/operations.js';
+import { applyImport, exportPackage, parseMappings, parseResolutions, previewImport, } from './markdown/package.js';
+import { isRecord } from './markdown/registry.js';
+import { SCOPES, isScope, presetSections } from './markdown/scope.js';
+import { buildInjectionSnapshot } from './markdown/snapshot.js';
+import { nowUtcMinute } from './markdown/timestamp.js';
+import { hostProjectId, normalizeRoot } from './project.js';
+import { DEFAULT_BUDGET, loadSettings, saveSettings, validateSettings } from './settings.js';
+export function hostProjectOf(workspace) {
+    const root = normalizeRoot(workspace.path);
+    return { id: hostProjectId(root), path: root, title: workspace.title };
+}
+/** The host project of a page request; an unknown id is refused, as VulcanCode refuses it. */
+export function resolveHost(hosts, projectId) {
+    const id = projectId?.trim();
+    if (id === undefined || id === '')
+        return undefined;
+    const host = hosts.find(item => item.id === id);
+    if (host === undefined)
+        throw MemoryError.invalid(`Unknown project: ${id}`);
+    return host;
+}
+export function settingsView(settings) {
+    return { ...settings, defaultBudget: DEFAULT_BUDGET, maxPartTokens: MAX_PART_TOKENS, warningPercent: BUDGET_WARNING_PERCENT };
+}
+export function loadOverview(store, hosts, host, memoryProjectId) {
+    const settings = loadSettings(store.memoryDirectory);
+    const registry = store.registry();
+    const bound = host === undefined ? undefined : registry.projectForHost(host.id)?.id;
+    const shownId = memoryProjectId ?? bound;
+    let documents = { user: store.load('user', undefined), space: store.load('space', undefined) };
+    if (shownId !== undefined) {
+        const project = registry.project(shownId);
+        if (project === undefined)
+            throw new MemoryError('project_unavailable', `Memory project \`${shownId}\` does not exist.`);
+        documents = { ...documents, project: { project, document: store.load('project', project.id) } };
+    }
+    const orphans = host === undefined ? [] : registry.orphanCandidates(host.id, host.path, undefined, existsSync);
+    return {
+        settings: settingsView(settings),
+        user: nodeViews(documents.user.views('user')),
+        space: nodeViews(documents.space.views('space')),
+        project: documents.project === undefined ? [] : nodeViews(documents.project.document.views('project')),
+        memoryProjectId: shownId ?? null,
+        boundMemoryProjectId: bound ?? null,
+        hostProjectId: host?.id ?? null,
+        orphanCandidates: orphans.map(candidate => ({ memoryProjectId: candidate.project.id, reasons: candidate.reasons })),
+        projects: registry.projects.map(projectView),
+        usage: buildInjectionSnapshot(documents, settings.budget).usage.map(usage => ({ ...usage })),
+        presetSections: SCOPES.flatMap(scope => presetSections(scope).map(([key, title]) => ({ scope, key, title }))),
+        hostProjects: hosts,
+    };
+}
+/** Write as the user; the first project write may create and bind a memory project. Disabled projects stay editable. */
+export function writeAsUser(store, hosts, host, memoryProjectId, operations) {
+    if (!Array.isArray(operations))
+        throw MemoryError.invalid('`operations` must be an array.');
+    const parsed = operations.map((operation, index) => {
+        try {
+            return parseWriteOperation(operation);
+        }
+        catch (error) {
+            throw error instanceof MemoryError ? MemoryError.invalid(`Operation ${index} is invalid: ${error.message}`) : error;
+        }
+    });
+    const context = {
+        ...host === undefined ? {} : { hostProjectId: host.id, rootPath: host.path },
+        ...memoryProjectId === undefined ? {} : { memoryProjectId },
+    };
+    const receipt = writeMemory(store, context, { session: undefined, source: 'user' }, loadSettings(store.memoryDirectory).budget, parsed);
+    return loadOverview(store, hosts, host, memoryProjectId ?? receipt.createdProject);
+}
+export function applyProjectAction(store, host, action) {
+    const now = nowUtcMinute();
+    const hostPath = () => {
+        if (host === undefined)
+            throw new MemoryError('project_unavailable', 'The host project is unknown.');
+        return host.path;
+    };
+    return store.updateRegistry((registry) => {
+        switch (action.action) {
+            case 'link':
+                registry.link(action.memoryProjectId, action.projectId, hostPath(), now);
+                break;
+            case 'create':
+                registry.createForHost(action.projectId, hostPath(), undefined, now);
+                break;
+            case 'ignore':
+                registry.ignoreHost(action.projectId);
+                break;
+            case 'set_enabled':
+                registry.setEnabled(action.memoryProjectId, action.enabled, now);
+                break;
+            case 'rename':
+                registry.rename(action.memoryProjectId, action.name, now);
+                break;
+        }
+        return registry.projects.map(projectView);
+    });
+}
+/** The host project a registry action names; only link, create and ignore name one. */
+export function actionHostId(action) {
+    return action.action === 'link' || action.action === 'create' || action.action === 'ignore' ? action.projectId : undefined;
+}
+export function readFile(store, scope, memoryProjectId) {
+    return { path: store.scopePath(scope, memoryProjectId), text: store.readFileText(scope, memoryProjectId) };
+}
+export function replaceFile(store, scope, memoryProjectId, expected, text) {
+    store.replaceFileText(scope, memoryProjectId, expected, text);
+    return { path: store.scopePath(scope, memoryProjectId), text };
+}
+function projectView(project) {
+    return {
+        id: project.id,
+        name: project.name,
+        hostProjectIds: [...project.hostProjectIds],
+        paths: [...project.paths],
+        memoryEnabled: project.memoryEnabled,
+        orphaned: project.paths.length > 0 && !project.paths.some(existsSync),
+        updated: project.updated,
+    };
+}
+function nodeViews(views) {
+    return views.map(view => ({
+        id: view.id,
+        level: view.level,
+        path: view.path,
+        section: view.section ?? null,
+        revision: view.revision,
+        body: view.body,
+        created: view.meta?.created ?? null,
+        updated: view.meta?.updated ?? null,
+        session: view.meta?.session ?? null,
+        source: view.meta?.source ?? null,
+        descendants: view.descendants,
+    }));
+}
+// ---- Request parsing: unknown fields are refused, as serde's `deny_unknown_fields` does. ----
+/** An object holding only the listed fields. */
+export function fields(value, allowed) {
+    if (!isRecord(value))
+        throw MemoryError.invalid('The request body must be a JSON object.');
+    const unknown = Object.keys(value).find(key => !allowed.includes(key));
+    if (unknown !== undefined)
+        throw MemoryError.invalid(`Unknown field \`${unknown}\`.`);
+    return value;
+}
+export function text(input, field) {
+    const value = input[field];
+    if (typeof value !== 'string')
+        throw MemoryError.invalid(`\`${field}\` must be a string.`);
+    return value;
+}
+export function optionalText(input, field) {
+    const value = input[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string')
+        throw MemoryError.invalid(`\`${field}\` must be a string.`);
+    return value;
+}
+function flag(input, field) {
+    const value = input[field];
+    if (typeof value !== 'boolean')
+        throw MemoryError.invalid(`\`${field}\` must be true or false.`);
+    return value;
+}
+export function scopeParam(value) {
+    if (!isScope(value))
+        throw MemoryError.invalid(`\`${String(value)}\` is not a memory scope.`);
+    return value;
+}
+export function parseProjectAction(value) {
+    if (!isRecord(value))
+        throw MemoryError.invalid('The request body must be a JSON object.');
+    switch (value['action']) {
+        case 'link': {
+            const input = fields(value, ['action', 'projectId', 'memoryProjectId']);
+            return { action: 'link', projectId: text(input, 'projectId'), memoryProjectId: text(input, 'memoryProjectId') };
+        }
+        case 'create':
+        case 'ignore': {
+            const input = fields(value, ['action', 'projectId']);
+            return { action: value['action'], projectId: text(input, 'projectId') };
+        }
+        case 'set_enabled': {
+            const input = fields(value, ['action', 'memoryProjectId', 'enabled']);
+            return { action: 'set_enabled', memoryProjectId: text(input, 'memoryProjectId'), enabled: flag(input, 'enabled') };
+        }
+        case 'rename': {
+            const input = fields(value, ['action', 'memoryProjectId', 'name']);
+            return { action: 'rename', memoryProjectId: text(input, 'memoryProjectId'), name: text(input, 'name') };
+        }
+        default: throw MemoryError.invalid('`action` must be link, create, ignore, set_enabled or rename.');
+    }
+}
+export function parseSettingsSave(value) {
+    const input = fields(value, ['mode', 'budget']);
+    const settings = { mode: input['mode'], budget: input['budget'] };
+    validateSettings(settings);
+    return settings;
+}
+/** Archive bytes sent by the page as base64. */
+export function archiveBytes(input) {
+    const encoded = text(input, 'archive');
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded))
+        throw MemoryError.invalid('`archive` must be base64.');
+    return new Uint8Array(Buffer.from(encoded, 'base64'));
+}
+export function exportRequest(store, value) {
+    const input = fields(value, ['user', 'space', 'memoryProjectIds']);
+    const ids = input['memoryProjectIds'] ?? [];
+    if (!Array.isArray(ids) || !ids.every(id => typeof id === 'string'))
+        throw MemoryError.invalid('`memoryProjectIds` must be an array of strings.');
+    const exported = exportPackage(store, { user: flag(input, 'user'), space: flag(input, 'space'), memoryProjectIds: ids });
+    return { fileName: exported.fileName, archive: Buffer.from(exported.bytes).toString('base64'), sha256: exported.sha256 };
+}
+export function previewRequest(store, value) {
+    const input = fields(value, ['archive', 'name', 'projects']);
+    return previewImport(store, archiveBytes(input), text(input, 'name'), parseMappings(input['projects']));
+}
+export function importRequest(store, value) {
+    const input = fields(value, ['archive', 'name', 'expectedSha256', 'projects', 'resolutions']);
+    return applyImport(store, archiveBytes(input), text(input, 'name'), text(input, 'expectedSha256'), parseMappings(input['projects']), parseResolutions(input['resolutions']));
+}
+export { saveSettings };

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/project.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The project a dsh session belongs to, for memory. A session is in the project of the directory
+ * it was created in (`SessionHeader.cwd`); the host project id is derived from that path, so
+ * every session opened in the same directory shares one project memory, and a moved checkout is
+ * offered for linking by the registry's orphan candidates.
+ */
+import type { ProjectContext } from './markdown/store.js';
+export declare const HOST_PROJECT_PREFIX = "dshproject-";
+/** The absolute directory without a trailing separator. */
+export declare function normalizeRoot(directory: string): string;
+/** Stable host project id of a root; Windows paths are case-insensitive, so they hash lowercased. */
+export declare function hostProjectId(root: string, platform?: NodeJS.Platform): string;
+/** The memory project context of a session created in `cwd`; none when the session has no directory. */
+export declare function projectContext(cwd: string | undefined): ProjectContext;

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/project.js

@@ -0,0 +1,27 @@
+/**
+ * The project a dsh session belongs to, for memory. A session is in the project of the directory
+ * it was created in (`SessionHeader.cwd`); the host project id is derived from that path, so
+ * every session opened in the same directory shares one project memory, and a moved checkout is
+ * offered for linking by the registry's orphan candidates.
+ */
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+export const HOST_PROJECT_PREFIX = 'dshproject-';
+/** The absolute directory without a trailing separator. */
+export function normalizeRoot(directory) {
+    const resolved = path.resolve(directory);
+    const root = path.parse(resolved).root;
+    return resolved.length > root.length ? resolved.replace(/[/\\]+$/, '') : resolved;
+}
+/** Stable host project id of a root; Windows paths are case-insensitive, so they hash lowercased. */
+export function hostProjectId(root, platform = process.platform) {
+    const key = platform === 'win32' ? root.toLowerCase() : root;
+    return `${HOST_PROJECT_PREFIX}${createHash('sha256').update(key).digest('hex').slice(0, 16)}`;
+}
+/** The memory project context of a session created in `cwd`; none when the session has no directory. */
+export function projectContext(cwd) {
+    if (cwd === undefined || cwd.trim() === '')
+        return {};
+    const rootPath = normalizeRoot(cwd);
+    return { hostProjectId: hostProjectId(rootPath), rootPath };
+}

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/settings.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `<dshHome>/vulcan-memory/settings.json`: the memory mode and the Markdown injection budget, the
+ * same shape as VulcanCode's `settings.rs`. A missing file means Markdown mode with the default
+ * budget and is never written back; only an explicit save writes it.
+ */
+/** `vmm` is a recognised mode with no implementation yet: nothing is registered or injected in it. */
+export type MemoryMode = 'off' | 'markdown' | 'vmm';
+export interface InjectionBudget {
+    readonly user: number;
+    readonly spaceBase: number;
+    readonly projectBase: number;
+    readonly spaceCatalog: number;
+    readonly projectCatalog: number;
+}
+export interface MemorySettings {
+    readonly mode: MemoryMode;
+    readonly budget: InjectionBudget;
+}
+export declare const DEFAULT_BUDGET: InjectionBudget;
+export declare const DEFAULT_SETTINGS: MemorySettings;
+export declare const SETTINGS_FILE = "settings.json";
+export declare function loadSettings(memoryDirectory: string): MemorySettings;
+export declare function saveSettings(memoryDirectory: string, settings: MemorySettings): void;
+export declare function parseSettings(text: string, file: string): MemorySettings;
+/** Check the shape and that every budget part is a whole number of at most {@link MAX_PART_TOKENS}. */
+export declare function validateSettings(settings: {
+    mode: unknown;
+    budget: unknown;
+}, file?: string): asserts settings is MemorySettings;

package/node_modules/@openvulcan/dsh-vulcan-memory/lib/settings.js

@@ -0,0 +1,62 @@
+/**
+ * `<dshHome>/vulcan-memory/settings.json`: the memory mode and the Markdown injection budget, the
+ * same shape as VulcanCode's `settings.rs`. A missing file means Markdown mode with the default
+ * budget and is never written back; only an explicit save writes it.
+ */
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { MAX_PART_TOKENS, SETTINGS_FORMAT_VERSION } from './markdown/constants.js';
+import { MemoryError } from './markdown/errors.js';
+import { isRecord } from './markdown/registry.js';
+import { writeAtomically } from './markdown/store.js';
+export const DEFAULT_BUDGET = { user: 500, spaceBase: 400, projectBase: 600, spaceCatalog: 1_000, projectCatalog: 1_500 };
+export const DEFAULT_SETTINGS = { mode: 'markdown', budget: DEFAULT_BUDGET };
+export const SETTINGS_FILE = 'settings.json';
+const BUDGET_KEYS = ['user', 'spaceBase', 'projectBase', 'spaceCatalog', 'projectCatalog'];
+export function loadSettings(memoryDirectory) {
+    const file = path.join(memoryDirectory, SETTINGS_FILE);
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return DEFAULT_SETTINGS;
+        throw MemoryError.io(file, 'read', error);
+    }
+    return parseSettings(text, file);
+}
+export function saveSettings(memoryDirectory, settings) {
+    validateSettings(settings);
+    writeAtomically(path.join(memoryDirectory, SETTINGS_FILE), `${JSON.stringify({ version: SETTINGS_FORMAT_VERSION, ...settings }, null, 2)}\n`);
+}
+export function parseSettings(text, file) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (error) {
+        throw MemoryError.json(file, error instanceof Error ? error.message : String(error));
+    }
+    if (!isRecord(value) || value['version'] !== SETTINGS_FORMAT_VERSION) {
+        throw new MemoryError('unsupported_format', `Memory settings \`${file}\` must declare format version ${SETTINGS_FORMAT_VERSION}.`);
+    }
+    if (Object.keys(value).some(key => !['version', 'mode', 'budget'].includes(key)))
+        throw MemoryError.json(file, 'unknown settings field');
+    const settings = { mode: value['mode'], budget: value['budget'] };
+    validateSettings(settings, file);
+    return settings;
+}
+/** Check the shape and that every budget part is a whole number of at most {@link MAX_PART_TOKENS}. */
+export function validateSettings(settings, file = SETTINGS_FILE) {
+    if (settings.mode !== 'off' && settings.mode !== 'markdown' && settings.mode !== 'vmm')
+        throw MemoryError.json(file, '`mode` must be off, markdown or vmm');
+    const budget = settings.budget;
+    if (!isRecord(budget) || Object.keys(budget).length !== BUDGET_KEYS.length
+        || !BUDGET_KEYS.every(key => Number.isSafeInteger(budget[key]) && budget[key] >= 0)) {
+        throw MemoryError.json(file, '`budget` must hold whole token counts for user, spaceBase, projectBase, spaceCatalog and projectCatalog');
+    }
+    if (BUDGET_KEYS.some(key => budget[key] > MAX_PART_TOKENS)) {
+        throw MemoryError.invalid(`Each memory injection budget part must be at most ${MAX_PART_TOKENS} tokens.`);
+    }
+}

package/node_modules/@openvulcan/dsh-vulcan-memory/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@openvulcan/dsh-vulcan-memory",
+  "version": "0.4.0",
+  "description": "Long-term Markdown memory for DeepSeek Harness, ported from VulcanCode: memory tools for the model, a per-conversation memory snapshot, the memory-curator skill and a memory page with import and export.",
+  "license": "MIT",
+  "icon": "./assets/memory-icon.png",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OpenVulcan/dsh-vulcancode.git",
+    "directory": "packages/dsh-vulcan-memory"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "!lib/**/*.test.*",
+    "assets"
+  ],
+  "engines": {
+    "dsh": ">=0.2.1-rc.2 <0.3.0"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar"
+      ]
+    }
+  },
+  "dependencies": {
+    "fflate": "^0.8.3",
+    "mdast-util-from-markdown": "^2.0.2",
+    "zod": "4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.5",
+    "@deepseek-ai/dsh-agent": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-connection": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-compaction": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-plan-mode": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-skill": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-workspace": "^0.2.1-rc.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/@openvulcan/dsh-vulcan-style/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenVulcan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.