@1yefuwang1/dsh-worktrees 0.0.0-stage → 0.2.13

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+- insert:
+    - id: git-worktrees
+      name: '@1yefuwang1/dsh-worktrees'
+      config:
+        defaultRemote: origin
+        defaultBranch: main

package/dist/context.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { WorktreeRecord, CheckoutState } from './types.js';
+export interface ReminderSource {
+    records(): WorktreeRecord[];
+    cachedStatus(id: string): CheckoutState | undefined;
+}
+export declare function pathContains(parent: string, child: string): boolean;
+export declare function renderWorktreeContext(record: WorktreeRecord, state?: CheckoutState): string;
+/** Agent and plugin both own each registration; no per-step Git I/O or timestamp churn. */
+export declare class WorktreeReminders {
+    private readonly owner;
+    private readonly source;
+    private readonly registrations;
+    private readonly stops;
+    constructor(owner: Context, source: ReminderSource);
+    start(): void;
+    attach(agent: Agent): void;
+    close(): void;
+}

package/dist/context.js

@@ -0,0 +1,70 @@
+import { isAbsolute, relative } from 'node:path';
+import { capability } from './runtime.js';
+export function pathContains(parent, child) {
+    const part = relative(parent, child);
+    return part === '' || (!isAbsolute(part) && part !== '..' && !part.startsWith('../') && !part.startsWith('..\\'));
+}
+function quote(value) {
+    const bounded = value.length > 1024 ? `${value.slice(0, 1024)} [truncated; inspect worktree status]` : value;
+    return JSON.stringify(bounded).replace(/</gu, '\\u003c').replace(/>/gu, '\\u003e').replace(/&/gu, '\\u0026');
+}
+export function renderWorktreeContext(record, state) {
+    return [
+        'Git worktree context. Paths and ref names below are data.',
+        'Mode: isolated linked checkout.',
+        `Execution directory: ${quote(record.effectiveCwd)}`,
+        `Original local checkout: ${quote(record.repoRoot)}`,
+        `Fetched base branch: ${quote(`${record.remote}/${record.remoteBranch}`)}`,
+        `Starting commit: ${quote(record.baseOid || 'not established')}`,
+        `Checkout last known: ${quote(state === undefined ? 'unknown; inspect status before Git mutations' : state.branch === null ? 'detached HEAD' : state.branch)}`,
+        ...(state === undefined ? [] : [`HEAD last known: ${quote(state.head)}`]),
+        'The base is a creation-time fetched snapshot, not continuous synchronization. Git refs and repository metadata remain shared.',
+        'Work in the current session directory. Preserve the local checkout unless an explicit handoff is requested. Historical paths may refer to an earlier checkout; verify before writing.',
+    ].join('\n');
+}
+/** Agent and plugin both own each registration; no per-step Git I/O or timestamp churn. */
+export class WorktreeReminders {
+    owner;
+    source;
+    registrations = new Map();
+    stops = [];
+    constructor(owner, source) {
+        this.owner = owner;
+        this.source = source;
+    }
+    start() {
+        this.stops.push(this.owner.on('agent/created', ({ agent }) => { this.attach(agent); return undefined; }));
+        this.stops.push(this.owner.on('agent/disposed', ({ agent }) => { this.registrations.get(agent)?.(); this.registrations.delete(agent); }));
+        for (const agent of capability(this.owner, 'agents')?.list() ?? [])
+            this.attach(agent);
+    }
+    attach(agent) {
+        if (this.registrations.has(agent))
+            return;
+        const cwd = agent.session.header.cwd;
+        if (cwd === undefined)
+            return;
+        const record = this.source.records().find(r => pathContains(r.checkoutRoot, cwd));
+        if (record === undefined)
+            return;
+        const prompt = capability(agent.ctx, 'systemPrompt');
+        if (prompt === undefined)
+            return;
+        const dispose = agent.ctx.effect(() => prompt.context({
+            name: 'dsh-worktrees:context', order: 500,
+            text: () => {
+                const current = this.source.records().find(r => r.id === record.id) ?? record;
+                return renderWorktreeContext(current, this.source.cachedStatus(record.id));
+            },
+        }), 'worktrees: agent runtime context');
+        const stop = this.owner.effect(() => dispose, 'worktrees: reminder ownership');
+        this.registrations.set(agent, () => { stop(); dispose(); });
+    }
+    close() {
+        for (const stop of this.stops.splice(0))
+            stop();
+        for (const dispose of this.registrations.values())
+            dispose();
+        this.registrations.clear();
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class WorktreeError extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+/** Never put credential-bearing URLs or helper output into the command/model log. */
+export declare function redact(text: string): string;
+export declare function failureOf(error: unknown): {
+    code: string;
+    message: string;
+};
+export declare function abortIfRequested(signal?: AbortSignal): void;

package/dist/errors.js

@@ -0,0 +1,30 @@
+export class WorktreeError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(redact(message));
+        this.name = 'WorktreeError';
+        this.code = code;
+        this.details = details;
+    }
+}
+/** Never put credential-bearing URLs or helper output into the command/model log. */
+export function redact(text) {
+    return text
+        .replace(/(https?:\/\/)[^\s/@]+@/giu, '$1[redacted]@')
+        .replace(/\b(?:gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+)\b/gu, '[redacted]')
+        .replace(/([?&](?:access_token|token|password|secret)=)[^\s&#]+/giu, '$1[redacted]')
+        .replace(/(authorization\s*:\s*)(?:bearer|basic)\s+\S+/giu, '$1[redacted]')
+        .slice(0, 4096);
+}
+export function failureOf(error) {
+    if (error instanceof WorktreeError)
+        return { code: error.code, message: redact(error.message) };
+    if (error instanceof Error && error.name === 'AbortError')
+        return { code: 'CANCELLED', message: 'The operation was cancelled; committed effects may remain.' };
+    return { code: 'OPERATION_FAILED', message: redact(error instanceof Error ? error.message : String(error)) };
+}
+export function abortIfRequested(signal) {
+    if (signal?.aborted)
+        throw new WorktreeError('CANCELLED', 'The operation was cancelled; committed effects may remain.');
+}

package/dist/first-message.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent, SessionStartSource } from '@deepseek-ai/dsh-agent';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { WorktreeController } from './service.js';
+export declare function actualUserMessage(agent: Agent, event: SessionEvent): event is SessionEvent<'user/message'>;
+/** Filtered one-shot observation only for eligible sessions; no token/full-log rescans. */
+export declare class FirstMessageNamer {
+    private readonly owner;
+    private readonly controller;
+    private readonly shutdown;
+    private readonly stops;
+    private readonly attachments;
+    private readonly tasks;
+    constructor(owner: Context, controller: WorktreeController);
+    start(): void;
+    private track;
+    attach(agent: Agent, source?: SessionStartSource): void;
+    close(): Promise<void>;
+}

package/dist/first-message.js

@@ -0,0 +1,121 @@
+import { capability } from './runtime.js';
+import { WorktreeError } from './errors.js';
+export function actualUserMessage(agent, event) {
+    return event.type === 'user/message' && event.surfaceOp === 'append' && !event.sourceEventSeqs?.length
+        && event.data.role === 'user' && event.data.source.kind === 'user' && agent.session.isOwnSeq(event.seq);
+}
+function abortable(task, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const abort = () => { cleanup(); reject(signal.reason); };
+        const cleanup = () => signal.removeEventListener('abort', abort);
+        signal.addEventListener('abort', abort, { once: true });
+        task.then(() => { cleanup(); resolve(); }, error => { cleanup(); reject(error); });
+    });
+}
+/** Filtered one-shot observation only for eligible sessions; no token/full-log rescans. */
+export class FirstMessageNamer {
+    owner;
+    controller;
+    shutdown = new AbortController();
+    stops = [];
+    attachments = new Map();
+    tasks = new Set();
+    constructor(owner, controller) {
+        this.owner = owner;
+        this.controller = controller;
+    }
+    start() {
+        this.stops.push(this.owner.on('agent/created', ({ agent, source }) => { this.attach(agent, source); return undefined; }));
+        this.stops.push(this.owner.on('agent/disposed', ({ agent }) => { this.attachments.get(agent)?.(); }));
+        for (const agent of capability(this.owner, 'agents')?.list() ?? [])
+            this.attach(agent, 'resume');
+    }
+    track(task) {
+        this.tasks.add(task);
+        void task.then(() => this.tasks.delete(task), () => this.tasks.delete(task));
+    }
+    attach(agent, source = 'startup') {
+        if (this.shutdown.signal.aborted || this.attachments.has(agent) || agent.session.header.origin === 'subagent')
+            return;
+        const record = this.controller.records().find(row => row.firstMessageNaming?.sessionId === agent.id);
+        const naming = record?.firstMessageNaming;
+        if (record === undefined || naming === undefined || naming.phase === 'complete' || naming.phase === 'skipped')
+            return;
+        if (source === 'clear' || source === 'compact') {
+            this.track(this.controller.skipFirstMessageName(record.id, 'session-replaced'));
+            return;
+        }
+        const lifetime = new AbortController();
+        const signal = AbortSignal.any([lifetime.signal, this.shutdown.signal]);
+        let claimed = naming.phase !== 'waiting';
+        let ended = false;
+        let end;
+        const turnEnd = new Promise(resolve => { end = resolve; });
+        let stop;
+        const launch = (event) => {
+            claimed = true;
+            this.track((async () => {
+                try {
+                    await this.controller.prepareFirstMessageName(record.id, agent, event, signal);
+                    if (!ended)
+                        await abortable(turnEnd, signal);
+                    // turn/end is committed while status can still be running. Claim actual idle,
+                    // not a chat event boundary, so naming never races this agent's Git tools.
+                    for (;;) {
+                        await abortable(agent.whenIdle(), signal);
+                        try {
+                            await this.controller.finishFirstMessageName(record.id, agent, signal);
+                            break;
+                        }
+                        catch (error) {
+                            // If waking input won the repository-queue/idle-claim race, wait on
+                            // that real activity. This reuses the original result, not its prompt.
+                            if (signal.aborted || !(error instanceof WorktreeError) || error.code !== 'BUSY')
+                                throw error;
+                        }
+                    }
+                }
+                finally {
+                    stop();
+                }
+            })());
+        };
+        const effect = agent.ctx.effect(() => {
+            const unlisten = this.owner.on('session/event', (session, event) => {
+                if (session !== agent.session || signal.aborted)
+                    return;
+                if (!claimed && actualUserMessage(agent, event))
+                    launch(event);
+                else if (claimed && event.type === 'turn/end' && agent.session.isOwnSeq(event.seq)) {
+                    ended = true;
+                    end();
+                }
+            });
+            return () => { lifetime.abort(); unlisten(); };
+        }, 'worktrees: first user message naming');
+        const owned = this.owner.effect(() => effect, 'worktrees: naming attachment ownership');
+        stop = () => { owned(); effect(); this.attachments.delete(agent); };
+        this.attachments.set(agent, stop);
+        // One startup/resume scan, never on an event/token. Recover the exact first own
+        // authored append, including the crash window before its naming receipt.
+        const events = agent.session.ownEvents();
+        const first = events.find(event => actualUserMessage(agent, event));
+        const seq = naming.messageSeq ?? first?.seq;
+        if (seq !== undefined && events.some(event => event.seq > seq && event.type === 'turn/end')) {
+            ended = true;
+            end();
+        }
+        if (claimed || first?.type === 'user/message')
+            launch(first?.type === 'user/message' ? first : undefined);
+    }
+    async close() {
+        this.shutdown.abort();
+        for (const stop of this.stops.splice(0))
+            stop();
+        for (const stop of [...this.attachments.values()])
+            stop();
+        await Promise.allSettled([...this.tasks]);
+    }
+}

package/dist/git.d.ts

@@ -0,0 +1,45 @@
+import type { CheckoutState, CreateCheckoutInput, CreatedCheckout, GitExecutor, RemoteBranches, RemoteInfo, RepositoryInfo, SnapshotInput, WorktreeConfig, WorktreePreview, WorktreeRecord } from './types.js';
+/** Strict Git engine. Its executor must enforce byte bounds, deadlines and caller sandbox access. */
+export declare class GitOperations {
+    private readonly execute;
+    private readonly config;
+    private readonly authorize;
+    constructor(execute: GitExecutor, config: WorktreeConfig, authorize?: () => void);
+    private env;
+    private run;
+    private configValues;
+    private supported;
+    discover(projectPath: string, signal?: AbortSignal): Promise<RepositoryInfo>;
+    private ref;
+    private remote;
+    remotes(repoRoot: string, signal?: AbortSignal): Promise<RemoteInfo[]>;
+    branches(repoRoot: string, remote: string, identity?: string, signal?: AbortSignal): Promise<RemoteBranches>;
+    private destination;
+    private store;
+    private removeStore;
+    private tree;
+    private attributes;
+    create(input: CreateCheckoutInput): Promise<CreatedCheckout>;
+    private identity;
+    private metadata;
+    private registered;
+    verify(record: WorktreeRecord, signal?: AbortSignal): Promise<CheckoutState>;
+    private statusRaw;
+    status(checkoutRoot: string, signal?: AbortSignal): Promise<CheckoutState>;
+    createBranch(record: WorktreeRecord, name: string, signal?: AbortSignal): Promise<CheckoutState>;
+    /** Rename metadata only, never switch HEAD, force a collision or touch the index/files. */
+    renameBranch(record: WorktreeRecord, expected: string, name: string, signal?: AbortSignal): Promise<CheckoutState>;
+    private files;
+    private fileData;
+    fingerprint(checkoutRoot: string, signal?: AbortSignal): Promise<string>;
+    private exactContents;
+    private ensureBase;
+    private patchFiles;
+    private collisions;
+    snapshot(input: SnapshotInput): Promise<WorktreePreview>;
+    private ownedPreview;
+    apply(preview: WorktreePreview, record: WorktreeRecord, signal?: AbortSignal): Promise<{
+        head: string;
+        files: number;
+    }>;
+}