@chatroomcp/chatroom 0.2.0 → 0.2.2

package/dist/plugins/web/http/git-api-router.js

@@ -0,0 +1,98 @@
+import { Router } from "express";
+import { ChatRoomError } from "../../../core/errors/chatroom-error.js";
+import { asyncRoute, requireString, } from "../../../presentation/http/http-utils.js";
+export function createGitApiRouter(application) {
+    const router = Router();
+    router.get("/git/status", asyncRoute(async (req, res) => {
+        const root = await resolveRoot(application, req.query.root);
+        res.json(await application.git.status(root));
+    }));
+    router.get("/git/diff", asyncRoute(async (req, res) => {
+        const root = await resolveRoot(application, req.query.root);
+        const filePath = typeof req.query.path === "string" ? req.query.path : undefined;
+        res.json(await application.git.diff(root, filePath));
+    }));
+    router.get("/git/branches", asyncRoute(async (req, res) => {
+        const root = await resolveRoot(application, req.query.root);
+        res.json(await application.git.branches(root));
+    }));
+    router.get("/git/log", asyncRoute(async (req, res) => {
+        const root = await resolveRoot(application, req.query.root);
+        const requested = Number(req.query.limit ?? 30);
+        const limit = Number.isFinite(requested) ? requested : 30;
+        res.json(await application.git.log(root, limit));
+    }));
+    router.post("/git/stage", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const root = await resolveRoot(application, body.root);
+        const paths = requireStringArray(body.paths, "paths");
+        res.json(await mutate(application, "git.stage", root, { paths }, () => application.git.stage(root, paths)));
+    }));
+    router.post("/git/unstage", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const root = await resolveRoot(application, body.root);
+        const paths = requireStringArray(body.paths, "paths");
+        res.json(await mutate(application, "git.unstage", root, { paths }, () => application.git.unstage(root, paths)));
+    }));
+    router.post("/git/restore", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const root = await resolveRoot(application, body.root);
+        const filePath = requireString(body.path, "path");
+        res.json(await mutate(application, "git.restore", root, { path: filePath }, () => application.git.restore(root, filePath)));
+    }));
+    router.post("/git/commit", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const root = await resolveRoot(application, body.root);
+        const message = requireString(body.message, "message");
+        res.json(await mutate(application, "git.commit", root, { message }, () => application.git.commit(root, message)));
+    }));
+    router.post("/git/branches", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const root = await resolveRoot(application, body.root);
+        const name = requireString(body.name, "name");
+        res.json(await mutate(application, "git.branch.create", root, { name }, () => application.git.createBranch(root, name)));
+    }));
+    router.post("/git/switch", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const root = await resolveRoot(application, body.root);
+        const name = requireString(body.name, "name");
+        res.json(await mutate(application, "git.branch.switch", root, { name }, () => application.git.switchBranch(root, name)));
+    }));
+    router.delete("/git/branches", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const root = await resolveRoot(application, body.root);
+        const name = requireString(body.name, "name");
+        res.json(await mutate(application, "git.branch.delete", root, { name }, () => application.git.deleteBranch(root, name)));
+    }));
+    for (const action of ["fetch", "pull", "push"]) {
+        router.post(`/git/${action}`, asyncRoute(async (req, res) => {
+            const body = bodyRecord(req.body);
+            const root = await resolveRoot(application, body.root);
+            res.json(await mutate(application, `git.${action}`, root, {}, () => application.git[action](root)));
+        }));
+    }
+    return router;
+}
+async function resolveRoot(application, value) {
+    return application.workspaces.resolve(requireString(value, "root"));
+}
+function bodyRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function requireStringArray(value, name) {
+    if (!Array.isArray(value) ||
+        value.length === 0 ||
+        value.some((item) => typeof item !== "string" || !item))
+        throw new ChatRoomError("INVALID_INPUT", `${name} must be a non-empty array of strings`);
+    return value;
+}
+function mutate(application, action, root, input, operation) {
+    return application.operations.run({
+        pluginId: "git",
+        source: "gui",
+        action,
+        input: { root, ...input },
+    }, operation);
+}

package/dist/plugins/web/http/workspace-api-router.js

@@ -4,34 +4,29 @@ import { asyncRoute, requireString, } from "../../../presentation/http/http-util
 export function createWorkspaceApiRouter(application) {
     const router = Router();
     router.get("/workspaces", asyncRoute(async (_req, res) => {
-        res.json(await application.discoverWorkspaces());
+        res.json(await application.workspaces.list());
     }));
-    router.get("/workspaces/:workspaceId", asyncRoute(async (req, res) => {
-        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
-        const workspace = application.getWorkspace(workspaceId);
-        const git = workspace.capabilities.git
-            ? await application.gitInfoQuery(workspace.id)
-            : null;
-        res.json({ ...workspace, git });
+    router.get("/workspace", asyncRoute(async (req, res) => {
+        res.json(await application.workspaces.info(requireString(req.query.root, "root")));
     }));
-    router.get("/workspaces/:workspaceId/files", asyncRoute(async (req, res) => {
-        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+    router.get("/workspace/files", asyncRoute(async (req, res) => {
+        const fs = await application.workspaces.fs(requireString(req.query.root, "root"));
         const filePath = typeof req.query.path === "string" ? req.query.path : ".";
-        const recursive = req.query.recursive === "1";
-        res.json(await application.listWorkspaceFiles(workspaceId, filePath, recursive));
+        res.json(await fs.list(filePath, { recursive: req.query.recursive === "1" }));
     }));
-    router.get("/workspaces/:workspaceId/file", asyncRoute(async (req, res) => {
-        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
-        const filePath = requireString(req.query.path, "path");
-        res.json(await application.readWorkspaceFile(workspaceId, filePath, 2 * 1024 * 1024));
+    router.get("/workspace/file", asyncRoute(async (req, res) => {
+        const fs = await application.workspaces.fs(requireString(req.query.root, "root"));
+        res.json(await fs.read(requireString(req.query.path, "path"), {
+            maxBytes: 2 * 1024 * 1024,
+        }));
     }));
-    router.get("/workspaces/:workspaceId/file/image", asyncRoute(async (req, res) => {
-        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+    router.get("/workspace/file/image", asyncRoute(async (req, res) => {
         const filePath = requireString(req.query.path, "path");
         const mime = imageMime(filePath);
         if (!mime)
             throw new ChatRoomError("INVALID_INPUT", "File type is not supported for image preview");
-        const file = await application.readWorkspaceFileBytes(workspaceId, filePath, 10 * 1024 * 1024);
+        const fs = await application.workspaces.fs(requireString(req.query.root, "root"));
+        const file = await fs.readBytes(filePath, { maxBytes: 10 * 1024 * 1024 });
         if (file.truncated)
             throw new ChatRoomError("INVALID_INPUT", "Image is too large to preview");
         res.setHeader("Content-Type", mime);
@@ -40,27 +35,10 @@ export function createWorkspaceApiRouter(application) {
         res.setHeader("X-Content-Type-Options", "nosniff");
         res.send(file.data);
     }));
-    router.get("/workspaces/:workspaceId/worktree/diff", asyncRoute(async (req, res) => {
-        res.json(await application.previewWorktreeApply(requireString(req.params.workspaceId, "workspaceId")));
-    }));
-    router.get("/workspaces/:workspaceId/worktree/diff/file", asyncRoute(async (req, res) => {
-        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
-        res.json(await application.previewWorktreeFileDiff(workspaceId, requireString(req.query.path, "path")));
-    }));
-    router.post("/workspaces/:workspaceId/worktree/apply", asyncRoute(async (req, res) => {
-        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
-        const body = (req.body ?? {});
-        if (body.paths !== undefined &&
-            (!Array.isArray(body.paths) ||
-                body.paths.some((value) => typeof value !== "string")))
-            throw new ChatRoomError("INVALID_INPUT", "paths must be an array of file paths");
-        res.json(await application.applyWorktree(workspaceId, body.paths));
-    }));
     return router;
 }
 function imageMime(filePath) {
-    const extension = filePath.split(".").pop()?.toLowerCase();
-    switch (extension) {
+    switch (filePath.split(".").pop()?.toLowerCase()) {
         case "png":
             return "image/png";
         case "jpg":

package/dist/plugins/web/plugin.js

@@ -1,18 +1,16 @@
 import { createServiceToken } from "../types.js";
-import { WorkspaceService } from "../workspace/plugin.js";
-import { ProcessService } from "../process/plugin.js";
 import { ComputerServiceToken } from "../computer/plugin.js";
+import { GitServiceToken } from "../git/plugin.js";
+import { ProcessService } from "../process/plugin.js";
+import { WorkspaceServiceToken } from "../workspace/plugin.js";
 import { WebRuntime } from "./runtime.js";
 export const WebServiceToken = createServiceToken("web");
 export function createWebPlugin() {
     return {
         id: "web",
         activate(context) {
-            const workspace = context.services.require(WorkspaceService);
-            const processes = context.services.require(ProcessService);
-            const computer = context.services.require(ComputerServiceToken);
             context.services.provide(WebServiceToken, {
-                application: new WebRuntime(workspace.workspaces, context.operations, processes, workspace.git, computer),
+                application: new WebRuntime(context.services.require(WorkspaceServiceToken), context.services.require(GitServiceToken), context.operations, context.services.require(ProcessService), context.services.require(ComputerServiceToken)),
             });
         },
     };

package/dist/plugins/web/runtime.d.ts

@@ -1,38 +1,16 @@
 import type { OperationLog } from "../../operations/operation-log.js";
-import type { WorkspaceService } from "../workspace/workspace-service.js";
-import type { ProcessSupervisor } from "../process/process-supervisor.js";
-import type { GitService } from "../workspace/git/git-service.js";
 import type { ComputerService } from "../computer/computer-service.js";
+import type { GitService } from "../git/git-service.js";
+import type { ProcessSupervisor } from "../process/process-supervisor.js";
+import type { WorkspaceService } from "../workspace/workspace-service.js";
 export declare class WebRuntime {
     readonly workspaces: WorkspaceService;
+    readonly git: GitService;
     readonly operations: OperationLog;
     readonly processes: ProcessSupervisor;
-    readonly git: GitService;
     readonly computer: ComputerService;
-    constructor(workspaces: WorkspaceService, operations: OperationLog, processes: ProcessSupervisor, git: GitService, computer: ComputerService);
-    previewWorktreeApply(workspaceId: string): Promise<import("./api-types.js").WorktreeApplyPreview>;
-    previewWorktreeFileDiff(workspaceId: string, filePath: string): Promise<import("./api-types.js").WorktreeFileDiff>;
-    applyWorktree(workspaceId: string, paths?: string[]): Promise<{
-        workspaceId: string;
-        bytes: number;
-        paths: string[];
-        conflicts: string[];
-    }>;
+    constructor(workspaces: WorkspaceService, git: GitService, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService);
     processKill(processId: string, force?: boolean): Promise<import("./api-types.js").ProcessSnapshot>;
     listProcesses(): import("./api-types.js").ProcessSnapshot[];
     getProcess(processId: string): import("./api-types.js").ProcessSnapshot;
-    discoverWorkspaces(): Promise<import("../workspace/domain/workspace.js").Workspace[]>;
-    getWorkspace(workspaceId: string): import("../workspace/domain/workspace.js").Workspace;
-    readWorkspaceFile(workspaceId: string, filePath: string, maxBytes?: number): Promise<{
-        content: string;
-        bytes: number;
-        truncated: boolean;
-    }>;
-    readWorkspaceFileBytes(workspaceId: string, filePath: string, maxBytes: number): Promise<{
-        data: Buffer;
-        bytes: number;
-        truncated: boolean;
-    }>;
-    listWorkspaceFiles(workspaceId: string, filePath?: string, recursive?: boolean): Promise<import("../workspace/domain/filesystem.js").FileInfo[]>;
-    gitInfoQuery(workspaceId: string): Promise<import("../workspace/domain/git.js").GitInfo>;
 }

package/dist/plugins/web/runtime.js

@@ -1,31 +1,16 @@
 export class WebRuntime {
     workspaces;
+    git;
     operations;
     processes;
-    git;
     computer;
-    constructor(workspaces, operations, processes, git, computer) {
+    constructor(workspaces, git, operations, processes, computer) {
         this.workspaces = workspaces;
+        this.git = git;
         this.operations = operations;
         this.processes = processes;
-        this.git = git;
         this.computer = computer;
     }
-    previewWorktreeApply(workspaceId) {
-        return this.workspaces.previewWorktreeApply(workspaceId);
-    }
-    previewWorktreeFileDiff(workspaceId, filePath) {
-        return this.workspaces.previewWorktreeFileDiff(workspaceId, filePath);
-    }
-    applyWorktree(workspaceId, paths) {
-        return this.operations.run({
-            pluginId: "workspace",
-            source: "gui",
-            action: "worktree.apply",
-            workspaceId,
-            input: { workspaceId, paths: paths ?? null },
-        }, () => this.workspaces.applyWorktree(workspaceId, paths));
-    }
     processKill(processId, force = false) {
         return this.operations.run({
             pluginId: "process",
@@ -41,28 +26,4 @@ export class WebRuntime {
     getProcess(processId) {
         return this.processes.read(processId);
     }
-    discoverWorkspaces() {
-        return this.workspaces.discoverGitWorkspaces();
-    }
-    getWorkspace(workspaceId) {
-        return this.workspaces.get(workspaceId);
-    }
-    async readWorkspaceFile(workspaceId, filePath, maxBytes) {
-        const fs = await this.workspaces.fs(workspaceId);
-        return fs.read(filePath, {
-            ...(maxBytes === undefined ? {} : { maxBytes }),
-        });
-    }
-    async readWorkspaceFileBytes(workspaceId, filePath, maxBytes) {
-        const fs = await this.workspaces.fs(workspaceId);
-        return fs.readBytes(filePath, { maxBytes });
-    }
-    async listWorkspaceFiles(workspaceId, filePath = ".", recursive = false) {
-        const fs = await this.workspaces.fs(workspaceId);
-        return fs.list(filePath, { recursive });
-    }
-    gitInfoQuery(workspaceId) {
-        const workspace = this.workspaces.markUsed(workspaceId);
-        return this.git.info(workspace.root);
-    }
 }

package/dist/plugins/workspace/mcp.js

@@ -1,139 +1,21 @@
 import { z } from "zod";
-import { changeSetSchema, closedRead, destructiveLocalMutation, fileInfoSchema, fileReadOutputSchema, fileWriteOutputSchema, localMutation, localWrite, searchMatchSchema, workspaceOutputSchema, } from "../../mcp/server/tool-support.js";
+import { closedRead } from "../../mcp/server/tool-support.js";
+const workspaceInfoSchema = z.object({
+    root: z.string(),
+    instructions: z.string().nullable(),
+    skills: z.array(z.object({
+        name: z.string(),
+        description: z.string(),
+        path: z.string(),
+    })),
+});
 export function registerWorkspaceTools(mcp, workspaces) {
-    mcp.registerTool("open_workspace", {
-        title: "Open workspace",
-        description: "Open or reuse an approved checkout, or create a new isolated managed Git worktree from the source checkout HEAD.",
-        inputSchema: z.object({
-            path: z.string(),
-            mode: z.enum(["checkout", "worktree"]).optional(),
-        }),
-        outputSchema: workspaceOutputSchema,
-        annotations: localMutation,
-        action: "open",
-    }, (input) => workspaces.open({
-        path: input.path,
-        ...(input.mode ? { mode: input.mode } : {}),
-    }));
-    mcp.registerTool("remove_workspace", {
-        title: "Remove workspace",
-        description: "Unregister a checkout workspace or remove a managed worktree. Dirty worktrees require force=true.",
-        inputSchema: z.object({
-            workspaceId: z.string(),
-            force: z.boolean().optional(),
-        }),
-        outputSchema: z.object({
-            removed: z.boolean(),
-            workspaceId: z.string(),
-            mode: z.enum(["checkout", "worktree"]),
-        }),
-        annotations: destructiveLocalMutation,
-        action: "remove",
-    }, async (input) => {
-        const removed = await workspaces.remove(input.workspaceId, input.force ?? false);
-        return { removed: true, workspaceId: removed.id, mode: removed.mode };
-    });
-    mcp.registerTool("fs_read", {
-        title: "Read file",
-        description: "Read a workspace-relative file through the ChatRoom filesystem boundary.",
-        inputSchema: z.object({
-            workspaceId: z.string(),
-            path: z.string(),
-            maxBytes: z
-                .number()
-                .int()
-                .positive()
-                .max(16 * 1024 * 1024)
-                .optional(),
-        }),
-        outputSchema: fileReadOutputSchema,
+    mcp.registerTool("workspace_info", {
+        title: "Workspace info",
+        description: "Read project instructions and skill metadata for a directory within the configured allowed roots.",
+        inputSchema: z.object({ root: z.string() }),
+        outputSchema: workspaceInfoSchema,
         annotations: closedRead,
-        action: "fs.read",
-    }, async (input) => {
-        const fs = await workspaces.fs(input.workspaceId);
-        return fs.read(input.path, input.maxBytes === undefined ? {} : { maxBytes: input.maxBytes });
-    });
-    mcp.registerTool("fs_write", {
-        title: "Write file",
-        description: "Atomically write a workspace-relative file.",
-        inputSchema: z.object({
-            workspaceId: z.string(),
-            path: z.string(),
-            content: z.string(),
-        }),
-        outputSchema: fileWriteOutputSchema,
-        annotations: localWrite,
-        action: "fs.write",
-    }, async (input) => {
-        const fs = await workspaces.fs(input.workspaceId);
-        return fs.write(input.path, input.content);
-    });
-    mcp.registerTool("fs_list", {
-        title: "List files",
-        description: "List files under a workspace-relative directory.",
-        inputSchema: z.object({
-            workspaceId: z.string(),
-            path: z.string().default("."),
-            recursive: z.boolean().default(false),
-        }),
-        outputSchema: z.object({ files: z.array(fileInfoSchema) }),
-        annotations: closedRead,
-        action: "fs.list",
-    }, async (input) => {
-        const fs = await workspaces.fs(input.workspaceId);
-        return {
-            files: await fs.list(input.path, { recursive: input.recursive }),
-        };
-    });
-    mcp.registerTool("fs_search", {
-        title: "Search files",
-        description: "Search text under a workspace.",
-        inputSchema: z.object({
-            workspaceId: z.string(),
-            query: z.string().min(1),
-            path: z.string().default("."),
-            maxResults: z.number().int().positive().max(2000).default(200),
-        }),
-        outputSchema: z.object({ matches: z.array(searchMatchSchema) }),
-        annotations: closedRead,
-        action: "fs.search",
-    }, async (input) => {
-        const fs = await workspaces.fs(input.workspaceId);
-        return {
-            matches: await fs.search(input.query, {
-                path: input.path,
-                maxResults: input.maxResults,
-            }),
-        };
-    });
-    mcp.registerTool("fs_patch", {
-        title: "Transactional patch",
-        description: "Validate all replacements before committing a multi-file text patch.",
-        inputSchema: z.object({
-            workspaceId: z.string(),
-            replacements: z
-                .array(z.object({
-                path: z.string(),
-                oldText: z.string().min(1),
-                newText: z.string(),
-                occurrence: z
-                    .union([z.number().int().positive(), z.literal("all")])
-                    .optional(),
-            }))
-                .min(1),
-        }),
-        outputSchema: changeSetSchema,
-        annotations: destructiveLocalMutation,
-        action: "fs.patch",
-    }, async (input) => {
-        const fs = await workspaces.fs(input.workspaceId);
-        return fs.patch(input.replacements.map((item) => ({
-            path: item.path,
-            oldText: item.oldText,
-            newText: item.newText,
-            ...(item.occurrence === undefined
-                ? {}
-                : { occurrence: item.occurrence }),
-        })));
-    });
+        action: "info",
+    }, (input) => workspaces.info(input.root));
 }

package/dist/plugins/workspace/metadata.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceFs } from "./workspace-fs.js";
+import type { WorkspaceSkill } from "./types.js";
+export declare function readInstructions(fs: WorkspaceFs): Promise<string | null>;
+export declare function readSkills(fs: WorkspaceFs): Promise<WorkspaceSkill[]>;

package/dist/plugins/workspace/metadata.js

@@ -0,0 +1,105 @@
+import path from "node:path";
+import { ChatRoomError } from "../../core/errors/chatroom-error.js";
+const SKILL_ROOTS = [".agents/skills", ".claude/skills", ".chatroom/skills"];
+const MAX_METADATA_BYTES = 64 * 1024;
+export async function readInstructions(fs) {
+    try {
+        return (await fs.read("AGENTS.md", { maxBytes: MAX_METADATA_BYTES }))
+            .content;
+    }
+    catch (error) {
+        if (error instanceof ChatRoomError && error.code === "NOT_FOUND")
+            return null;
+        throw error;
+    }
+}
+export async function readSkills(fs) {
+    const paths = [];
+    for (const root of SKILL_ROOTS) {
+        try {
+            const entries = await fs.list(root, {
+                recursive: true,
+                maxEntries: 2000,
+            });
+            for (const entry of entries) {
+                if (entry.type === "file" && entry.path.endsWith("/SKILL.md"))
+                    paths.push(entry.path);
+            }
+        }
+        catch (error) {
+            if (!(error instanceof ChatRoomError) || error.code !== "NOT_FOUND")
+                throw error;
+        }
+    }
+    return Promise.all([...new Set(paths)].sort().map(async (skillPath) => {
+        const fallbackName = path.posix.basename(path.posix.dirname(skillPath));
+        try {
+            const file = await fs.read(skillPath, { maxBytes: MAX_METADATA_BYTES });
+            const metadata = parseSkillFrontmatter(file.content);
+            return {
+                name: metadata.name || fallbackName,
+                description: metadata.description,
+                path: skillPath,
+            };
+        }
+        catch (error) {
+            if (!(error instanceof ChatRoomError) || error.code !== "NOT_FOUND")
+                throw error;
+            return { name: fallbackName, description: "", path: skillPath };
+        }
+    }));
+}
+function parseSkillFrontmatter(content) {
+    const lines = content
+        .replace(/^\uFEFF/, "")
+        .replaceAll("\r\n", "\n")
+        .split("\n");
+    if (lines[0]?.trim() !== "---")
+        return { name: "", description: "" };
+    const end = lines.findIndex((line, index) => index > 0 && ["---", "..."].includes(line.trim()));
+    if (end < 0)
+        return { name: "", description: "" };
+    const values = new Map();
+    for (let index = 1; index < end; index++) {
+        const match = /^([A-Za-z0-9_-]+):(?:\s*(.*))?$/.exec(lines[index] ?? "");
+        if (!match)
+            continue;
+        const key = match[1] ?? "";
+        if (key !== "name" && key !== "description")
+            continue;
+        const raw = match[2] ?? "";
+        if (/^[>|][+-]?\d?$/.test(raw.trim())) {
+            const block = [];
+            while (index + 1 < end) {
+                const next = lines[index + 1] ?? "";
+                if (next && !/^\s/.test(next))
+                    break;
+                index++;
+                block.push(next.replace(/^\s+/, ""));
+            }
+            values.set(key, raw.trim().startsWith(">")
+                ? block.join(" ").replace(/\s+/g, " ").trim()
+                : block.join("\n").trim());
+            continue;
+        }
+        values.set(key, parseYamlScalar(raw));
+    }
+    return {
+        name: values.get("name")?.trim() ?? "",
+        description: values.get("description")?.trim() ?? "",
+    };
+}
+function parseYamlScalar(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed.slice(1, -1);
+        }
+    }
+    if (trimmed.length >= 2 && trimmed.startsWith("'") && trimmed.endsWith("'"))
+        return trimmed.slice(1, -1).replaceAll("''", "'");
+    return trimmed;
+}

package/dist/plugins/workspace/plugin.d.ts

@@ -1,10 +1,4 @@
 import type { InternalPlugin } from "../types.js";
-import { GitService } from "./git/git-service.js";
-import { WorkspaceService as WorkspaceRuntime } from "./workspace-service.js";
-interface WorkspacePluginService {
-    workspaces: WorkspaceRuntime;
-    git: GitService;
-}
-export declare const WorkspaceService: import("../types.js").ServiceToken<WorkspacePluginService>;
+import { WorkspaceService } from "./workspace-service.js";
+export declare const WorkspaceServiceToken: import("../types.js").ServiceToken<WorkspaceService>;
 export declare function createWorkspacePlugin(): InternalPlugin;
-export {};

package/dist/plugins/workspace/plugin.js

@@ -1,34 +1,22 @@
-import { CommandRunner } from "../../core/runtime/command-runner.js";
 import { createServiceToken } from "../types.js";
-import { GitCommandRunner } from "./git/git-command-runner.js";
-import { GitService } from "./git/git-service.js";
-import { GitSnapshotService } from "./git/git-snapshot-service.js";
-import { WorkspaceRepository } from "./infrastructure/workspace-repository.js";
 import { registerWorkspaceTools } from "./mcp.js";
-import { WorkspaceService as WorkspaceRuntime } from "./workspace-service.js";
-import { WorktreeReviewService } from "./worktree-review-service.js";
-export const WorkspaceService = createServiceToken("workspace");
+import { WorkspaceService } from "./workspace-service.js";
+export const WorkspaceServiceToken = createServiceToken("workspace");
 export function createWorkspacePlugin() {
-    let value = null;
+    let service = null;
     return {
         id: "workspace",
         async activate(context) {
-            const gitRunner = new GitCommandRunner(new CommandRunner());
-            const git = new GitService(gitRunner);
-            const snapshots = new GitSnapshotService(gitRunner, git);
-            const review = new WorktreeReviewService(git, snapshots);
-            const workspaces = await WorkspaceRuntime.create(new WorkspaceRepository(context.database), git, review, context.config.allowedRoots, context.config.dataDir);
-            await workspaces.discoverGitWorkspaces();
-            value = { workspaces, git };
-            context.services.provide(WorkspaceService, value);
+            service = await WorkspaceService.create(context.config.allowedRoots);
+            context.services.provide(WorkspaceServiceToken, service);
         },
         registerMcp(mcp) {
-            if (!value)
+            if (!service)
                 throw new Error("Workspace plugin is not active");
-            registerWorkspaceTools(mcp, value.workspaces);
+            registerWorkspaceTools(mcp, service);
         },
         deactivate() {
-            value = null;
+            service = null;
         },
     };
 }

package/dist/plugins/workspace/types.d.ts

@@ -0,0 +1,18 @@
+export interface WorkspaceEntry {
+    root: string;
+}
+export interface WorkspaceSkill {
+    name: string;
+    description: string;
+    path: string;
+}
+export interface WorkspaceInfo {
+    root: string;
+    instructions: string | null;
+    skills: WorkspaceSkill[];
+}
+export interface WorkspaceFile {
+    path: string;
+    type: "file" | "directory" | "symlink";
+    size: number;
+}