dsh-prompt-vcs 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 (2026-09-18)
+
+Initial release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hj01857655
+
+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.

package/README.md

@@ -0,0 +1,30 @@
+# dsh-prompt-vcs
+
+Every change to your agent's instructions is recorded with a diff, and any change can be undone.
+
+## Install
+
+```sh
+dsh plugin --profile web add dsh-prompt-vcs
+```
+
+## What it does
+
+- **Watch the instruction surface.** `AGENTS.md`, `CLAUDE.md`, skill files.
+- **Snapshot on change.** Unified diff + attribution (user / plugin / agent) stored in `.promptvcs/history.jsonl`.
+- **Timeline.** `promptvcs log` shows every change: when, what file, who changed it.
+- **Diff.** `promptvcs diff <hash>` shows the unified diff for a specific change.
+- **Rollback.** `promptvcs rollback <hash>` restores a file to its state before a change.
+- **Panel.** Timeline with inline diffs and rollback button.
+
+## CLI
+
+```sh
+dsh-prompt-vcs log               # show change history
+dsh-prompt-vcs diff <hash>       # show diff for a change
+dsh-prompt-vcs rollback <hash>   # undo a change
+```
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# cordis patch for dsh-prompt-vcs
+insert:
+  - id: dsh-prompt-vcs
+    from: ./lib/index.js

package/lib/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from './cli.js';
+process.exitCode = run(process.argv.slice(2));

package/lib/cli.d.ts

@@ -0,0 +1 @@
+export declare function run(argv: string[]): number;

package/lib/cli.js

@@ -0,0 +1,45 @@
+import { parseArgs } from 'node:util';
+import { PromptVcs } from './vcs.js';
+export function run(argv) {
+    const { positionals } = parseArgs({ args: argv, allowPositionals: true });
+    const vcs = new PromptVcs(process.cwd());
+    const cmd = positionals[0] ?? 'log';
+    switch (cmd) {
+        case 'log': {
+            const tl = vcs.timeline();
+            if (tl.length === 0) {
+                console.log('No changes recorded.');
+                return 0;
+            }
+            for (const e of tl) {
+                console.log(`${e.hash}  ${new Date(e.timestamp).toLocaleString()}  ${e.changedBy}  ${e.file}  +${e.addedLines} -${e.removedLines}`);
+            }
+            return 0;
+        }
+        case 'diff': {
+            const hash = positionals[1] ?? '';
+            const diff = vcs.getDiff(hash);
+            if (diff === null) {
+                console.log('Change not found.');
+                return 1;
+            }
+            console.log(diff);
+            return 0;
+        }
+        case 'rollback': {
+            const hash = positionals[1] ?? '';
+            const ok = vcs.rollback(hash);
+            if (!ok) {
+                console.log('Change not found.');
+                return 1;
+            }
+            console.log(`Rolled back ${hash}.`);
+            return 0;
+        }
+        case 'help':
+        default:
+            console.log('Usage: dsh-prompt-vcs <command>');
+            console.log('Commands: log, diff <hash>, rollback <hash>');
+            return 0;
+    }
+}

package/lib/client/index.d.ts

@@ -0,0 +1,4 @@
+export declare const inject: string[];
+export declare function apply(ctx: {
+    inject: (deps: string[], fn: (...services: unknown[]) => void) => void;
+}): void;

package/lib/client/index.js

@@ -0,0 +1,16 @@
+import { renderPanel } from './view.js';
+export const inject = ['@deepseek-ai/dsh-client-ui-settings', '@deepseek-ai/dsh-client-connection'];
+export function apply(ctx) {
+    ctx.inject(inject, (settings, connection) => {
+        const s = settings;
+        const c = connection;
+        s.section('prompt-vcs', {
+            title: 'Prompt VCS',
+            render: async () => {
+                const res = await c.fetch('/api/vcs.panel');
+                const payload = await res.json();
+                return renderPanel(payload);
+            },
+        });
+    });
+}

package/lib/client/view.d.ts

@@ -0,0 +1,2 @@
+import type { PanelPayload } from '../types.js';
+export declare function renderPanel(payload: PanelPayload): string;

package/lib/client/view.js

@@ -0,0 +1,6 @@
+export function renderPanel(payload) {
+    const rows = payload.timeline
+        .map((e) => `<tr><td>${e.hash}</td><td>${new Date(e.timestamp).toLocaleString()}</td><td>${e.changedBy}</td><td>${e.file}</td><td>+${e.addedLines}</td><td>-${e.removedLines}</td></tr>`)
+        .join('');
+    return `<div class="vcs-panel"><h2>Prompt VCS</h2>${rows ? `<table><thead><tr><th>Hash</th><th>Date</th><th>By</th><th>File</th><th>+</th><th>-</th></tr></thead><tbody>${rows}</tbody></table>` : '<p>No changes recorded.</p>'}</div>`;
+}

package/lib/diff.d.ts

@@ -0,0 +1,7 @@
+/** Unified diff generation (line-level). */
+export interface DiffResult {
+    diff: string;
+    added: number;
+    removed: number;
+}
+export declare function unifiedDiff(oldText: string, newText: string, oldPath?: string, newPath?: string): DiffResult;

package/lib/diff.js

@@ -0,0 +1,72 @@
+/** Unified diff generation (line-level). */
+export function unifiedDiff(oldText, newText, oldPath = 'a', newPath = 'b') {
+    const oldLines = oldText === '' ? [] : oldText.split('\n');
+    const newLines = newText === '' ? [] : newText.split('\n');
+    const lines = [];
+    let added = 0;
+    let removed = 0;
+    // Header
+    lines.push(`--- ${oldPath}`);
+    lines.push(`+++ ${newPath}`);
+    // Simple LCS-based diff
+    const lcs = computeLCS(oldLines, newLines);
+    let oi = 0;
+    let ni = 0;
+    let li = 0;
+    while (oi < oldLines.length || ni < newLines.length) {
+        if (li < lcs.length && oi < oldLines.length && ni < newLines.length && oldLines[oi] === lcs[li] && newLines[ni] === lcs[li]) {
+            lines.push(` ${lcs[li]}`);
+            oi++;
+            ni++;
+            li++;
+        }
+        else if (oi < oldLines.length && (li >= lcs.length || oldLines[oi] !== lcs[li])) {
+            lines.push(`-${oldLines[oi]}`);
+            removed++;
+            oi++;
+        }
+        else if (ni < newLines.length && (li >= lcs.length || newLines[ni] !== lcs[li])) {
+            lines.push(`+${newLines[ni]}`);
+            added++;
+            ni++;
+        }
+        else {
+            oi++;
+            ni++;
+            li++;
+        }
+    }
+    return { diff: lines.join('\n'), added, removed };
+}
+function computeLCS(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            if (a[i] === b[j]) {
+                dp[i][j] = dp[i + 1][j + 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+            }
+        }
+    }
+    const result = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (a[i] === b[j]) {
+            result.push(a[i]);
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            i++;
+        }
+        else {
+            j++;
+        }
+    }
+    return result;
+}

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { PromptVcs } from './vcs.js';
+export declare const name = "dsh-prompt-vcs";
+export interface VcsService {
+    recordChange(file: string, oldContent: string, newContent: string, changedBy?: 'user' | 'plugin' | 'agent', pluginId?: string): ReturnType<PromptVcs['recordChange']>;
+    timeline(): ReturnType<PromptVcs['timeline']>;
+    getDiff(hash: string): ReturnType<PromptVcs['getDiff']>;
+    rollback(hash: string): boolean;
+    panel(): ReturnType<PromptVcs['panel']>;
+}
+export declare function apply(ctx: Context): void;

package/lib/index.js

@@ -0,0 +1,17 @@
+import { resolve } from 'node:path';
+import { PromptVcs } from './vcs.js';
+import { registerVcsRoutes } from './routes.js';
+export const name = 'dsh-prompt-vcs';
+export function apply(ctx) {
+    const root = resolve(process.cwd());
+    const vcs = new PromptVcs(root);
+    const service = {
+        recordChange: (file, oldContent, newContent, changedBy, pluginId) => vcs.recordChange(file, oldContent, newContent, changedBy, pluginId),
+        timeline: () => vcs.timeline(),
+        getDiff: (hash) => vcs.getDiff(hash),
+        rollback: (hash) => vcs.rollback(hash),
+        panel: () => vcs.panel(),
+    };
+    ctx.provide('promptVcs', service);
+    registerVcsRoutes(ctx, service);
+}

package/lib/routes.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { VcsService } from './index.js';
+import { VCS_PANEL_PATH } from './vcs.js';
+export { VCS_PANEL_PATH };
+export declare function registerVcsRoutes(ctx: Context, vcs: VcsService): void;

package/lib/routes.js

@@ -0,0 +1,50 @@
+import { VCS_PANEL_PATH } from './vcs.js';
+export { VCS_PANEL_PATH };
+export function registerVcsRoutes(ctx, vcs) {
+    ctx.inject(['connection'], (connectionCtx) => {
+        const connection = connectionCtx.connection;
+        connection.fetch.register({
+            path: VCS_PANEL_PATH,
+            methods: ['GET'],
+            requestBody: 'buffered',
+            fetch: () => Promise.resolve(Response.json(vcs.panel(), {
+                headers: { 'cache-control': 'no-store' },
+            })),
+        });
+        connection.fetch.register({
+            path: '/api/vcs.diff',
+            methods: ['GET'],
+            requestBody: 'buffered',
+            fetch: async (request) => {
+                const url = new URL(request.url);
+                const hash = url.searchParams.get('hash');
+                if (!hash)
+                    return Response.json({ error: 'missing hash' }, { status: 400 });
+                const diff = vcs.getDiff(hash);
+                if (diff === null)
+                    return Response.json({ error: 'not found' }, { status: 404 });
+                return Response.json({ diff }, { headers: { 'cache-control': 'no-store' } });
+            },
+        });
+        connection.fetch.register({
+            path: '/api/vcs.rollback',
+            methods: ['POST'],
+            requestBody: 'buffered',
+            fetch: async (request) => {
+                let body;
+                try {
+                    body = await request.json();
+                }
+                catch {
+                    return Response.json({ error: 'invalid JSON' }, { status: 400 });
+                }
+                if (!body.hash)
+                    return Response.json({ error: 'missing hash' }, { status: 400 });
+                const ok = vcs.rollback(body.hash);
+                if (!ok)
+                    return Response.json({ error: 'not found' }, { status: 404 });
+                return Response.json({ ok: true });
+            },
+        });
+    });
+}

package/lib/store.d.ts

@@ -0,0 +1,11 @@
+import type { Change } from './types.js';
+export declare class VcsStore {
+    private readonly projectDir;
+    private readonly vcsDir;
+    private readonly historyPath;
+    constructor(projectDir: string);
+    private ensureDir;
+    append(change: Change): void;
+    readAll(): Change[];
+    static hashChange(file: string, oldContent: string, newContent: string): string;
+}

package/lib/store.js

@@ -0,0 +1,36 @@
+import { readFileSync, existsSync, mkdirSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+export class VcsStore {
+    projectDir;
+    vcsDir;
+    historyPath;
+    constructor(projectDir) {
+        this.projectDir = projectDir;
+        this.vcsDir = join(projectDir, '.promptvcs');
+        this.historyPath = join(this.vcsDir, 'history.jsonl');
+    }
+    ensureDir() {
+        if (!existsSync(this.vcsDir))
+            mkdirSync(this.vcsDir, { recursive: true });
+    }
+    append(change) {
+        this.ensureDir();
+        appendFileSync(this.historyPath, JSON.stringify(change) + '\n', 'utf8');
+    }
+    readAll() {
+        if (!existsSync(this.historyPath))
+            return [];
+        return readFileSync(this.historyPath, 'utf8')
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    static hashChange(file, oldContent, newContent) {
+        return createHash('sha256')
+            .update(`${file}:${oldContent}:${newContent}:${Date.now()}`)
+            .digest('hex')
+            .slice(0, 12);
+    }
+}

package/lib/types.d.ts

@@ -0,0 +1,23 @@
+export interface Change {
+    hash: string;
+    timestamp: number;
+    file: string;
+    changedBy: 'user' | 'plugin' | 'agent';
+    pluginId?: string;
+    addedLines: number;
+    removedLines: number;
+    diff: string;
+    oldContent: string;
+    newContent: string;
+}
+export interface TimelineEntry {
+    hash: string;
+    timestamp: number;
+    file: string;
+    changedBy: string;
+    addedLines: number;
+    removedLines: number;
+}
+export interface PanelPayload {
+    timeline: TimelineEntry[];
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+// Types for dsh-prompt-vcs
+export {};

package/lib/vcs.d.ts

@@ -0,0 +1,17 @@
+import type { Change, TimelineEntry, PanelPayload } from './types.js';
+export declare const VCS_PANEL_PATH = "/api/vcs.panel";
+export declare class PromptVcs {
+    private projectDir;
+    private store;
+    constructor(projectDir: string);
+    /** Record a change to a file. Called when a watched file is modified. */
+    recordChange(file: string, oldContent: string, newContent: string, changedBy?: 'user' | 'plugin' | 'agent', pluginId?: string): Change | null;
+    /** Snapshot a file's current content, detecting changes since last snapshot. */
+    checkFile(file: string, lastKnownContent: string | null): Change | null;
+    timeline(): TimelineEntry[];
+    getDiff(hash: string): string | null;
+    /** Rollback a file to its state before the given change. */
+    rollback(hash: string): boolean;
+    panel(): PanelPayload;
+    static get watchedFiles(): string[];
+}

package/lib/vcs.js

@@ -0,0 +1,80 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { VcsStore } from './store.js';
+import { unifiedDiff } from './diff.js';
+export const VCS_PANEL_PATH = '/api/vcs.panel';
+/** Files that shape agent behaviour — the instruction surface. */
+const WATCHED_FILES = ['AGENTS.md', 'CLAUDE.md'];
+export class PromptVcs {
+    projectDir;
+    store;
+    constructor(projectDir) {
+        this.projectDir = projectDir;
+        this.store = new VcsStore(projectDir);
+    }
+    /** Record a change to a file. Called when a watched file is modified. */
+    recordChange(file, oldContent, newContent, changedBy = 'user', pluginId) {
+        if (oldContent === newContent)
+            return null;
+        const rel = relative(this.projectDir, file);
+        const { diff, added, removed } = unifiedDiff(oldContent, newContent, rel, rel);
+        const hash = VcsStore.hashChange(file, oldContent, newContent);
+        const change = {
+            hash,
+            timestamp: Date.now(),
+            file: rel,
+            changedBy,
+            addedLines: added,
+            removedLines: removed,
+            diff,
+            oldContent,
+            newContent,
+        };
+        if (pluginId !== undefined)
+            change.pluginId = pluginId;
+        this.store.append(change);
+        return change;
+    }
+    /** Snapshot a file's current content, detecting changes since last snapshot. */
+    checkFile(file, lastKnownContent) {
+        const fullPath = join(this.projectDir, file);
+        if (!existsSync(fullPath))
+            return null;
+        const current = readFileSync(fullPath, 'utf8');
+        if (lastKnownContent === current)
+            return null;
+        return this.recordChange(fullPath, lastKnownContent ?? '', current);
+    }
+    timeline() {
+        return this.store.readAll().map((c) => ({
+            hash: c.hash,
+            timestamp: c.timestamp,
+            file: c.file,
+            changedBy: c.changedBy,
+            addedLines: c.addedLines,
+            removedLines: c.removedLines,
+        }));
+    }
+    getDiff(hash) {
+        const change = this.store.readAll().find((c) => c.hash === hash);
+        return change?.diff ?? null;
+    }
+    /** Rollback a file to its state before the given change. */
+    rollback(hash) {
+        const changes = this.store.readAll();
+        const change = changes.find((c) => c.hash === hash);
+        if (!change)
+            return false;
+        const fullPath = join(this.projectDir, change.file);
+        writeFileSync(fullPath, change.oldContent, 'utf8');
+        // Record the rollback itself
+        this.recordChange(fullPath, change.newContent, change.oldContent, 'user');
+        return true;
+    }
+    panel() {
+        return { timeline: this.timeline() };
+    }
+    static get watchedFiles() {
+        return WATCHED_FILES;
+    }
+}

package/lib/vcs.web.js

@@ -0,0 +1,26 @@
+// src/client/view.tsx
+function renderPanel(payload) {
+  const rows = payload.timeline.map((e) => `<tr><td>${e.hash}</td><td>${new Date(e.timestamp).toLocaleString()}</td><td>${e.changedBy}</td><td>${e.file}</td><td>+${e.addedLines}</td><td>-${e.removedLines}</td></tr>`).join("");
+  return `<div class="vcs-panel"><h2>Prompt VCS</h2>${rows ? `<table><thead><tr><th>Hash</th><th>Date</th><th>By</th><th>File</th><th>+</th><th>-</th></tr></thead><tbody>${rows}</tbody></table>` : "<p>No changes recorded.</p>"}</div>`;
+}
+
+// src/client/index.tsx
+var inject = ["@deepseek-ai/dsh-client-ui-settings", "@deepseek-ai/dsh-client-connection"];
+function apply(ctx) {
+  ctx.inject(inject, (settings, connection) => {
+    const s = settings;
+    const c = connection;
+    s.section("prompt-vcs", {
+      title: "Prompt VCS",
+      render: async () => {
+        const res = await c.fetch("/api/vcs.panel");
+        const payload = await res.json();
+        return renderPanel(payload);
+      }
+    });
+  });
+}
+export {
+  apply,
+  inject
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "dsh-prompt-vcs",
+  "version": "0.1.0",
+  "description": "Every change to your agent's instructions is recorded with a diff, and any change can be undone.",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "bin": { "dsh-prompt-vcs": "lib/bin.js" },
+  "exports": {
+    ".": { "types": "./lib/index.d.ts", "default": "./lib/index.js" },
+    "./client": { "types": "./lib/client.d.ts", "default": "./lib/vcs.web.js" },
+    "./package.json": "./package.json"
+  },
+  "files": ["lib", "cordis.patch.yml", "README.md", "CHANGELOG.md"],
+  "keywords": ["dsh", "dsh-plugin", "deepseek-harness", "prompt", "vcs", "version-control", "diff"],
+  "dsh": {
+    "bundle": { "patch": "./cordis.patch.yml" },
+    "client": {
+      "platform": "web",
+      "inject": ["@deepseek-ai/dsh-client-ui-settings", "@deepseek-ai/dsh-client-connection"]
+    }
+  },
+  "license": "MIT",
+  "author": "hj01857655",
+  "repository": { "type": "git", "url": "git+https://github.com/hj01857655/dsh-prompt-vcs.git" },
+  "bugs": { "url": "https://github.com/hj01857655/dsh-prompt-vcs/issues" },
+  "homepage": "https://github.com/hj01857655/dsh-prompt-vcs#readme",
+  "engines": { "node": ">=20" },
+  "peerDependencies": { "@deepseek-ai/cordis": "^4.0.1" },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@types/node": "^22.20.3",
+    "@types/react": "^19.3.0",
+    "esbuild": "^0.28.2",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "typescript": "^5.6.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/bundle-client.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json",
+    "test": "tsc -p tsconfig.json && node --test tests/*.test.mjs",
+    "prepublishOnly": "npm run build && npm test"
+  }
+}