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

package/dist/project-store.d.ts

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import type { RecordTable } from './store.js';
+import type { ProjectRecord, ProjectThreadBinding } from './projects.js';
+export declare const projectFolderSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strict>;
+export declare const projectRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    folders: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strict>>;
+    mainFolderId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    imported: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const projectBindingSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    projectId: z.ZodString;
+    folderId: z.ZodString;
+    mode: z.ZodEnum<{
+        worktree: "worktree";
+        local: "local";
+    }>;
+    effectiveCwd: z.ZodString;
+    worktreeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export interface ProjectStartRecord {
+    id: string;
+    projectId: string;
+    folderId: string;
+    actorId: string | null;
+    effectiveCwd: string;
+    requestedSessionId: string;
+    phase: 'planned' | 'creating' | 'session-created' | 'ready' | 'recovery-required';
+    sessionId: string | null;
+    workspaceId: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface ProjectRemovalRecord {
+    id: string;
+    folders: {
+        id: string;
+        path: string;
+    }[];
+    removedAt: number;
+}
+export declare const projectRemovalSchema: z.ZodObject<{
+    id: z.ZodString;
+    folders: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    removedAt: z.ZodNumber;
+}, z.core.$strict>;
+/** Separate plugin-owned metadata; the existing worktree domain is not migrated or changed.
+ * Additive v1 table: storageDomain and the JSON backend load missing tables as empty;
+ * existing v1 records retain their schemas and version stamps (no migration needed).
+ */
+export declare const projectDomain: {
+    name: string;
+    version: number;
+    layout: "per-record";
+    tables: {
+        projects: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            title: string;
+            folders: {
+                id: string;
+                path: string;
+                title: string;
+            }[];
+            createdAt: number;
+            updatedAt: number;
+            mainFolderId?: string | undefined;
+            imported?: boolean | undefined;
+        }>;
+        bindings: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            sessionId: string;
+            projectId: string;
+            folderId: string;
+            mode: "worktree" | "local";
+            effectiveCwd: string;
+            worktreeId?: string | undefined;
+        }>;
+        starts: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            projectId: string;
+            folderId: string;
+            actorId: string | null;
+            effectiveCwd: string;
+            requestedSessionId: string;
+            phase: "creating" | "ready" | "recovery-required" | "planned" | "session-created";
+            sessionId: string | null;
+            workspaceId: string | null;
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        removals: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            folders: {
+                id: string;
+                path: string;
+            }[];
+            removedAt: number;
+        }>;
+    };
+};
+export interface ProjectStore {
+    projects: RecordTable<ProjectRecord>;
+    bindings: RecordTable<ProjectThreadBinding>;
+    starts: RecordTable<ProjectStartRecord>;
+    removals: RecordTable<ProjectRemovalRecord>;
+    close(): Promise<void>;
+}

package/dist/project-store.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { isAbsolute } from 'node:path';
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+const text = z.string().min(1).max(4096);
+const path = text.refine(value => isAbsolute(value) && !/[\u0000-\u001f\u007f]/u.test(value));
+export const projectFolderSchema = z.object({ id: text, path, title: z.string().max(4096) }).strict();
+export const projectRecordSchema = z.object({
+    id: z.string().uuid(), title: z.string().min(1).max(120), folders: z.array(projectFolderSchema).min(1).max(32), mainFolderId: text.optional(),
+    createdAt: z.number().int().nonnegative(), updatedAt: z.number().int().nonnegative(), imported: z.boolean().optional(),
+}).strict().refine(value => value.mainFolderId === undefined || value.folders.some(folder => folder.id === value.mainFolderId), { path: ['mainFolderId'], message: 'The main folder must be a member of the project.' });
+export const projectBindingSchema = z.object({
+    sessionId: z.string().min(1).max(256), projectId: z.string().uuid(), folderId: text,
+    mode: z.enum(['local', 'worktree']), effectiveCwd: path, worktreeId: z.string().uuid().optional(),
+}).strict().refine(value => value.mode === 'worktree' ? value.worktreeId !== undefined : value.worktreeId === undefined);
+const startSchema = z.object({
+    id: z.string().uuid(), projectId: z.string().uuid(), folderId: text, actorId: z.string().min(1).max(256).nullable(),
+    effectiveCwd: path, requestedSessionId: z.string().min(1).max(256),
+    phase: z.enum(['planned', 'creating', 'session-created', 'ready', 'recovery-required']),
+    sessionId: z.string().min(1).max(256).nullable(), workspaceId: text.nullable(),
+    createdAt: z.number().int().nonnegative(), updatedAt: z.number().int().nonnegative(),
+}).strict();
+export const projectRemovalSchema = z.object({
+    id: z.string().uuid(), folders: z.array(projectFolderSchema.omit({ title: true })).min(1).max(32), removedAt: z.number().int().nonnegative(),
+}).strict();
+/** Separate plugin-owned metadata; the existing worktree domain is not migrated or changed.
+ * Additive v1 table: storageDomain and the JSON backend load missing tables as empty;
+ * existing v1 records retain their schemas and version stamps (no migration needed).
+ */
+export const projectDomain = defineDomain({
+    name: 'dsh_worktree_projects', version: 1, layout: 'per-record',
+    tables: { projects: domainTable(projectRecordSchema), bindings: domainTable(projectBindingSchema), starts: domainTable(startSchema), removals: domainTable(projectRemovalSchema) },
+});

package/dist/projects.d.ts

@@ -0,0 +1,149 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { localProjectPath } from './runtime.js';
+import { SessionBootstrap } from './sessions.js';
+import { type ProjectStore } from './project-store.js';
+import type { WorktreeRecord } from './types.js';
+export interface ProjectFolder {
+    id: string;
+    path: string;
+    title: string;
+}
+export interface ProjectRecord {
+    id: string;
+    title: string;
+    folders: ProjectFolder[];
+    mainFolderId?: string;
+    createdAt: number;
+    updatedAt: number;
+    imported?: boolean;
+}
+/** Legacy records select their first folder; an explicit main ID must name a member. */
+export declare function resolveMainFolder(project: Pick<ProjectRecord, 'folders' | 'mainFolderId'>): ProjectFolder;
+export interface ProjectThreadBinding {
+    sessionId: string;
+    projectId: string;
+    folderId: string;
+    mode: 'local' | 'worktree';
+    effectiveCwd: string;
+    worktreeId?: string;
+}
+export interface ProjectSnapshot {
+    projects: ProjectRecord[];
+    bindings: ProjectThreadBinding[];
+    records?: WorktreeRecord[];
+}
+export type ProjectRequest = {
+    action: 'list';
+    projectId?: string;
+} | {
+    action: 'create';
+    id: string;
+    title: string;
+    folders: string[];
+    mainFolder?: string;
+} | {
+    action: 'update';
+    projectId: string;
+    title?: string;
+    folders?: string[];
+    mainFolder?: string;
+} | {
+    action: 'remove';
+    projectId: string;
+} | {
+    action: 'bind';
+    projectId: string;
+    folderId: string;
+    sessionId: string;
+} | {
+    action: 'start';
+    operationId: string;
+    projectId: string;
+    folderId?: string;
+};
+export interface ProjectInvocation {
+    agent?: Agent;
+    origin: 'ui' | 'tool' | 'command';
+    signal: AbortSignal;
+}
+export interface ProjectRemoveResult {
+    removed: true;
+    projectId: string;
+    scope: 'project-metadata';
+}
+export interface ProjectStartResult {
+    sessionId: string;
+    workspaceId: string;
+    binding: ProjectThreadBinding;
+}
+export interface ProjectWorktreeSource {
+    records(): WorktreeRecord[];
+}
+type BootstrapApi = Pick<SessionBootstrap, 'actor' | 'isLive' | 'settings' | 'create' | 'close'>;
+export interface ProjectDependencies {
+    bootstrap?: BootstrapApi;
+    localPath?: typeof localProjectPath;
+    operationTimeoutMs?: number;
+}
+/** Lossless, bounded plain JSON validation shared by the tool parser and quiet RPC. */
+export declare function projectJsonSnapshot(value: unknown, code?: string): unknown;
+export declare function parseProjectRequest(input: unknown): ProjectRequest;
+/** Plain JSON schema, not a Zod object. Folder updates replace the complete folder array. */
+export declare const parameterSchema: Record<string, unknown>;
+export declare const projectParameterSchema: Record<string, unknown>;
+/** Durable project membership never changes native workspace paths, session cwd, files or history. */
+export declare class ProjectController {
+    private readonly owner;
+    private readonly store;
+    private readonly worktrees;
+    private readonly dependencies;
+    private readonly bootstrap;
+    private readonly shutdown;
+    private readonly flights;
+    private readonly headers;
+    private queue;
+    private closed;
+    private closing;
+    constructor(owner: Context, store: ProjectStore, worktrees: ProjectWorktreeSource, dependencies?: ProjectDependencies);
+    records(): ProjectRecord[];
+    /** Internal read-only selection from a known managed row, never from a fabricated session ID. */
+    selectionForWorktree(worktreeId: string): {
+        projectId: string;
+        folderId: string;
+        path: string;
+    } | undefined;
+    resolveFolder(projectId: string, folderId?: string): ProjectFolder;
+    private startFolder;
+    folderForPath(path: string): {
+        projectId: string;
+        folderId: string;
+        path: string;
+    } | undefined;
+    bindingFor(sessionId: string, cwd?: string): ProjectThreadBinding | undefined;
+    execute(request: ProjectRequest, invocation: ProjectInvocation): Promise<unknown>;
+    synchronize(): Promise<void>;
+    /** Internal metadata-only import after admission; removed sources remain independent of projects. */
+    ensureFolder(path: string, signal?: AbortSignal): Promise<{
+        projectId: string;
+        folderId: string;
+        path: string;
+    } | undefined>;
+    recordThread(binding: ProjectThreadBinding): Promise<void>;
+    close(): Promise<void>;
+    private serial;
+    private guard;
+    private infer;
+    private worktreeFolder;
+    private inspect;
+    private snapshot;
+    private synchronizeNow;
+    private suppressedFolder;
+    /** Cleanup is metadata-only and may finish after cancellation once the receipt commits. */
+    private finishRemoval;
+    private removeProject;
+    private canonicalFolders;
+    private changeProject;
+    private start;
+}
+export {};