@piecemaker-legal/piecemaker 1.0.0

package/server/modules/worktrees/tests/worktrees.routes.test.ts

@@ -0,0 +1,199 @@
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import type { AddressInfo } from 'node:net';
+import test from 'node:test';
+
+import express, {
+  type NextFunction,
+  type Request,
+  type Response,
+} from 'express';
+
+import { createWorktreesRouter } from '@/modules/worktrees/worktrees.routes.js';
+import type {
+  CreateWorktreeInput,
+  WorktreeServices,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+function createFakeServices(overrides: Partial<WorktreeServices> = {}): WorktreeServices {
+  const unused = async (): Promise<never> => {
+    throw new Error('Unexpected Worktrees service call');
+  };
+
+  return {
+    resolveProjectPath: () => {
+      throw new Error('Unexpected project resolution');
+    },
+    list: unused,
+    create: unused,
+    createAndOpen: unused,
+    open: unused,
+    merge: unused,
+    remove: unused,
+    ...overrides,
+  };
+}
+
+async function withWorktreesServer(
+  services: WorktreeServices,
+  run: (baseUrl: string) => Promise<void>,
+): Promise<void> {
+  const app = express();
+  app.use(express.json());
+  app.use('/api/worktrees', createWorktreesRouter(services));
+  app.use((error: unknown, _req: Request, res: Response, _next: NextFunction) => {
+    if (error instanceof AppError) {
+      res.status(error.statusCode).json({ error: error.code });
+      return;
+    }
+
+    res.status(500).json({ error: 'INTERNAL_ERROR' });
+  });
+
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    await run(`http://127.0.0.1:${address.port}`);
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+    });
+  }
+}
+
+test('create route parses input and invokes the create-and-open application service', async () => {
+  const createInputs: CreateWorktreeInput[] = [];
+  const services = createFakeServices({
+    resolveProjectPath: (projectId) => {
+      assert.equal(projectId, 'project-1');
+      return '/workspace/repo';
+    },
+    createAndOpen: async (input) => {
+      createInputs.push(input);
+      return {
+        worktreePath: '/workspace/repo-worktrees/feature-login',
+        branch: input.branch,
+        createdBranch: true,
+        project: {
+          projectId: 'worktree-project-1',
+          path: '/workspace/repo-worktrees/feature-login',
+          fullPath: '/workspace/repo-worktrees/feature-login',
+          displayName: 'repo worktree',
+          isStarred: false,
+          sessions: [],
+          sessionMeta: { hasMore: false, total: 0 },
+        },
+      };
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/worktrees/create`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: ' project-1 ',
+        branch: ' feature/login ',
+        baseBranch: 'main',
+      }),
+    });
+    const payload = await response.json() as {
+      success: boolean;
+      data: { project: { projectId: string } };
+    };
+
+    assert.equal(response.status, 200);
+    assert.equal(payload.success, true);
+    assert.equal(payload.data.project.projectId, 'worktree-project-1');
+  });
+
+  assert.deepEqual(createInputs, [{
+    projectPath: '/workspace/repo',
+    branch: 'feature/login',
+    baseBranch: 'main',
+  }]);
+});
+
+test('create route rejects missing branch before calling a mutation service', async () => {
+  let createCalled = false;
+  const services = createFakeServices({
+    resolveProjectPath: () => '/workspace/repo',
+    createAndOpen: async () => {
+      createCalled = true;
+      throw new Error('create should not run for invalid input');
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/worktrees/create`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ project: 'project-1' }),
+    });
+    const payload = await response.json() as { error: string };
+
+    assert.equal(response.status, 400);
+    assert.equal(payload.error, 'INVALID_REQUEST_BODY');
+  });
+
+  assert.equal(createCalled, false);
+});
+
+test('merge and remove routes do not coerce string booleans to true', async () => {
+  const mergeInputs: Array<{ squash?: boolean; removeAfterMerge?: boolean }> = [];
+  const removeInputs: Array<{ force?: boolean; deleteBranch?: boolean }> = [];
+  const services = createFakeServices({
+    resolveProjectPath: () => '/workspace/repo',
+    merge: async (input) => {
+      mergeInputs.push(input);
+      return {
+        mergedBranch: 'feature/login',
+        targetBranch: 'main',
+        squash: false,
+        removedWorktree: null,
+        cleanupError: null,
+      };
+    },
+    remove: async (input) => {
+      removeInputs.push(input);
+      return {
+        removedPath: input.worktreePath,
+        branch: 'feature/login',
+        branchDeleted: false,
+        archivedProjectId: null,
+        archivalError: null,
+      };
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const body = {
+      project: 'project-1',
+      worktreePath: '/workspace/repo-worktrees/feature-login',
+      squash: 'false',
+      removeAfterMerge: 'false',
+      force: 'false',
+      deleteBranch: 'false',
+    };
+    const mergeResponse = await fetch(`${baseUrl}/api/worktrees/merge`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const removeResponse = await fetch(`${baseUrl}/api/worktrees/remove`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    assert.equal(mergeResponse.status, 200);
+    assert.equal(removeResponse.status, 200);
+  });
+
+  assert.equal(mergeInputs[0].squash, false);
+  assert.equal(mergeInputs[0].removeAfterMerge, false);
+  assert.equal(removeInputs[0].force, false);
+  assert.equal(removeInputs[0].deleteBranch, false);
+});

package/server/modules/worktrees/worktrees.module.ts

@@ -0,0 +1,113 @@
+import { access } from 'node:fs/promises';
+
+import { projectsDb } from '@/modules/database/index.js';
+import {
+  createProject,
+  deleteOrArchiveProject,
+  restoreArchivedProject,
+} from '@/modules/projects/index.js';
+import type {
+  WorktreeFileSystem,
+  WorktreeProjectGateway,
+  WorktreeServices,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+import { createWorktree } from '@/modules/worktrees/services/worktree-create.service.js';
+import { createAndOpenWorktree } from '@/modules/worktrees/services/worktree-create-and-open.service.js';
+import { runGitCommand } from '@/modules/worktrees/services/worktree-git.service.js';
+import { listWorktrees } from '@/modules/worktrees/services/worktree-list.service.js';
+import { mergeWorktree } from '@/modules/worktrees/services/worktree-merge.service.js';
+import { openWorktreeAsProject } from '@/modules/worktrees/services/worktree-open.service.js';
+import { removeWorktree } from '@/modules/worktrees/services/worktree-remove.service.js';
+import { createWorktreesRouter } from '@/modules/worktrees/worktrees.routes.js';
+
+/**
+ * Real filesystem adapter used only by Worktrees production composition.
+ *
+ * Services depend on the shared capability type and therefore cannot touch a
+ * developer's filesystem unless this adapter is explicitly supplied.
+ */
+const worktreeFileSystem: WorktreeFileSystem = {
+  async pathExists(candidatePath: string): Promise<boolean> {
+    try {
+      await access(candidatePath);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+};
+
+/**
+ * Projects boundary for Worktrees production workflows.
+ *
+ * Imports are deliberately restricted to the Database and Projects barrel
+ * files. No Worktrees service knows which repository or project service backs
+ * these operations.
+ */
+const worktreeProjects: WorktreeProjectGateway = {
+  getProjectPathById: (projectId) => projectsDb.getProjectPathById(projectId),
+  getProjectByPath: (projectPath) => projectsDb.getProjectPath(projectPath),
+  createProject: (input) => createProject(input),
+  restoreProject: (projectId) => restoreArchivedProject(projectId),
+  archiveProject: (projectId) => deleteOrArchiveProject(projectId, false),
+};
+
+const remove: WorktreeServices['remove'] = (input) => removeWorktree(input, {
+  runGit: runGitCommand,
+  projects: worktreeProjects,
+});
+
+const create: WorktreeServices['create'] = (input) => createWorktree(input, {
+  runGit: runGitCommand,
+  fileSystem: worktreeFileSystem,
+});
+
+const open: WorktreeServices['open'] = (input) => openWorktreeAsProject(input, {
+  runGit: runGitCommand,
+  projects: worktreeProjects,
+});
+
+/**
+ * Production Worktrees application-service surface.
+ *
+ * This is the module's composition root: it is the only location that combines
+ * concrete adapters with the independently testable workflow functions.
+ */
+const worktreeServices: WorktreeServices = {
+  resolveProjectPath(projectId) {
+    const projectPath = worktreeProjects.getProjectPathById(projectId);
+    if (!projectPath) {
+      throw new AppError(`Unable to resolve project path for "${projectId}"`, {
+        code: 'PROJECT_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    return projectPath;
+  },
+  list: (input) => listWorktrees(input, {
+    runGit: runGitCommand,
+    getProjectByPath: worktreeProjects.getProjectByPath,
+  }),
+  create,
+  createAndOpen: (input) => createAndOpenWorktree(input, {
+    createWorktree: create,
+    openWorktree: open,
+    removeWorktree: remove,
+  }),
+  open,
+  merge: (input) => mergeWorktree(input, {
+    runGit: runGitCommand,
+    removeWorktree: remove,
+  }),
+  remove,
+};
+
+/**
+ * Worktrees router mounted by the server entrypoint at `/api/worktrees`.
+ *
+ * It is assembled here so other modules consume only the Worktrees barrel and
+ * cannot depend on route or service implementation files.
+ */
+export const worktreesRoutes = createWorktreesRouter(worktreeServices);

package/server/modules/worktrees/worktrees.routes.ts

@@ -0,0 +1,116 @@
+import express from 'express';
+
+import type { WorktreeServices } from '@/shared/types.js';
+import { AppError, asyncHandler, createApiSuccessResponse } from '@/shared/utils.js';
+
+/**
+ * Parses the project identifier shared by all Worktrees routes.
+ *
+ * Path resolution intentionally remains in the injected application service so
+ * this transport layer never reaches into the Database module.
+ */
+function readProjectId(projectIdValue: unknown): string {
+  const projectId = typeof projectIdValue === 'string' ? projectIdValue.trim() : '';
+  if (!projectId) {
+    throw new AppError('project is required', {
+      code: 'PROJECT_ID_REQUIRED',
+      statusCode: 400,
+    });
+  }
+
+  return projectId;
+}
+
+function readRequiredString(value: unknown, name: string): string {
+  const parsed = typeof value === 'string' ? value.trim() : '';
+  if (!parsed) {
+    throw new AppError(`${name} is required`, {
+      code: 'INVALID_REQUEST_BODY',
+      statusCode: 400,
+    });
+  }
+  return parsed;
+}
+
+/**
+ * Builds the Worktrees HTTP router around an injected application-service API.
+ *
+ * Keeping construction explicit lets route tests supply deterministic services
+ * and ensures parsing remains the route layer's only responsibility.
+ */
+export function createWorktreesRouter(services: WorktreeServices): express.Router {
+  const router = express.Router();
+
+  router.get(
+    '/',
+    asyncHandler(async (req, res) => {
+      const projectPath = services.resolveProjectPath(readProjectId(req.query.project));
+      const result = await services.list({ projectPath });
+      res.json(createApiSuccessResponse(result));
+    }),
+  );
+
+  router.post(
+    '/create',
+    asyncHandler(async (req, res) => {
+      const body = req.body as Record<string, unknown>;
+      const projectPath = services.resolveProjectPath(readProjectId(body.project));
+      const branch = readRequiredString(body.branch, 'branch');
+      const baseBranch = typeof body.baseBranch === 'string' ? body.baseBranch : null;
+
+      const result = await services.createAndOpen({ projectPath, branch, baseBranch });
+      res.json(createApiSuccessResponse(result));
+    }),
+  );
+
+  router.post(
+    '/open',
+    asyncHandler(async (req, res) => {
+      const body = req.body as Record<string, unknown>;
+      const projectPath = services.resolveProjectPath(readProjectId(body.project));
+      const worktreePath = readRequiredString(body.worktreePath, 'worktreePath');
+
+      const project = await services.open({ projectPath, worktreePath });
+      res.json(createApiSuccessResponse({ project }));
+    }),
+  );
+
+  router.post(
+    '/merge',
+    asyncHandler(async (req, res) => {
+      const body = req.body as Record<string, unknown>;
+      const projectPath = services.resolveProjectPath(readProjectId(body.project));
+      const worktreePath = readRequiredString(body.worktreePath, 'worktreePath');
+
+      const result = await services.merge({
+        projectPath,
+        worktreePath,
+        squash: typeof body.squash === 'boolean' ? body.squash : false,
+        message: typeof body.message === 'string' ? body.message : null,
+        removeAfterMerge: typeof body.removeAfterMerge === 'boolean' ? body.removeAfterMerge : false,
+      });
+
+      res.json(createApiSuccessResponse(result));
+    }),
+  );
+
+  router.post(
+    '/remove',
+    asyncHandler(async (req, res) => {
+      const body = req.body as Record<string, unknown>;
+      const projectPath = services.resolveProjectPath(readProjectId(body.project));
+      const worktreePath = readRequiredString(body.worktreePath, 'worktreePath');
+
+      const result = await services.remove({
+        projectPath,
+        worktreePath,
+        force: typeof body.force === 'boolean' ? body.force : false,
+        deleteBranch: typeof body.deleteBranch === 'boolean' ? body.deleteBranch : false,
+      });
+
+      res.json(createApiSuccessResponse(result));
+    }),
+  );
+
+  return router;
+}

package/server/piecemaker/activation/claude-mcp.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+/**
+ * Serveurs MCP Claude Code visibles pour un dossier : union de la portée
+ * utilisateur et des deux portées projet (`~/.claude.json` → `projects[...]`
+ * et `<dossier>/.mcp.json`), sans importer `claude-mcp.provider.ts` — les
+ * formes lues ici en sont la copie manuelle, jamais l'inverse.
+ *
+ * L'état activé/désactivé vient de `disabledMcpServers`, fusionné depuis les
+ * trois fichiers de réglages Claude Code (global, projet partagé, projet
+ * local) : la bascule n'écrit que le fichier local, mais la lecture doit
+ * refléter une désactivation posée à n'importe quel niveau.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { displayPath } = require('./paths.cjs');
+
+function readJsonSafe(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeJsonPretty(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+function claudeSettingsLocalPath(workspacePath) {
+  return path.join(workspacePath, '.claude', 'settings.local.json');
+}
+
+function readMergedDisabledMcpServers(workspacePath, userHome) {
+  const disabled = new Set();
+  const files = [
+    path.join(userHome, '.claude', 'settings.json'),
+    path.join(workspacePath, '.claude', 'settings.json'),
+    claudeSettingsLocalPath(workspacePath),
+  ];
+  for (const filePath of files) {
+    const settings = readJsonSafe(filePath);
+    if (Array.isArray(settings.disabledMcpServers)) {
+      for (const name of settings.disabledMcpServers) disabled.add(name);
+    }
+  }
+  return disabled;
+}
+
+function describeServer(config) {
+  if (!config || typeof config !== 'object') return undefined;
+  if (typeof config.command === 'string') {
+    const args = Array.isArray(config.args) ? config.args.join(' ') : '';
+    return args ? `${config.command} ${args}` : config.command;
+  }
+  if (typeof config.url === 'string') return config.url;
+  return undefined;
+}
+
+function listClaudeMcp(workspacePath, userHome) {
+  const userConfig = readJsonSafe(path.join(userHome, '.claude.json'));
+  const userServers = userConfig.mcpServers && typeof userConfig.mcpServers === 'object' ? userConfig.mcpServers : {};
+  const projects = userConfig.projects && typeof userConfig.projects === 'object' ? userConfig.projects : {};
+  const projectEntry = projects[workspacePath] && typeof projects[workspacePath] === 'object' ? projects[workspacePath] : {};
+  const projectScopedServers = projectEntry.mcpServers && typeof projectEntry.mcpServers === 'object' ? projectEntry.mcpServers : {};
+  const mcpJsonConfig = readJsonSafe(path.join(workspacePath, '.mcp.json'));
+  const mcpJsonServers = mcpJsonConfig.mcpServers && typeof mcpJsonConfig.mcpServers === 'object' ? mcpJsonConfig.mcpServers : {};
+
+  const disabled = readMergedDisabledMcpServers(workspacePath, userHome);
+  const sources = [
+    { servers: mcpJsonServers, origin: 'project', source: displayPath(path.join(workspacePath, '.mcp.json'), userHome) },
+    { servers: projectScopedServers, origin: 'project', source: displayPath(path.join(userHome, '.claude.json'), userHome) },
+    { servers: userServers, origin: 'user', source: displayPath(path.join(userHome, '.claude.json'), userHome) },
+  ];
+
+  const byName = new Map();
+  for (const { servers, origin, source } of sources) {
+    for (const [name, config] of Object.entries(servers)) {
+      if (byName.has(name)) continue;
+      byName.set(name, {
+        id: name,
+        name,
+        description: describeServer(config),
+        origin,
+        source,
+        enabled: !disabled.has(name),
+        toggleable: true,
+      });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function toggleClaudeMcp(workspacePath, userHome, name, enabled) {
+  const settingsPath = claudeSettingsLocalPath(workspacePath);
+  const settings = readJsonSafe(settingsPath);
+  const current = Array.isArray(settings.disabledMcpServers) ? settings.disabledMcpServers : [];
+  const withoutName = current.filter((entry) => entry !== name);
+  settings.disabledMcpServers = enabled ? withoutName : [...withoutName, name];
+  writeJsonPretty(settingsPath, settings);
+  return listClaudeMcp(workspacePath, userHome).find((item) => item.id === name)
+    ?? { id: name, name, origin: 'project', source: displayPath(settingsPath, userHome), enabled, toggleable: true };
+}
+
+module.exports = {
+  listClaudeMcp,
+  toggleClaudeMcp,
+  claudeSettingsLocalPath,
+  readJsonSafe,
+  writeJsonPretty,
+};

package/server/piecemaker/activation/claude-plugins.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+/**
+ * Plugins de marketplace installés pour Claude Code. L'état activé/désactivé
+ * fusionne le réglage global (`~/.claude/settings.json`) et le réglage local
+ * au dossier (`<dossier>/.claude/settings.local.json`, qui l'emporte), la
+ * bascule n'écrivant jamais que ce second fichier.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { displayPath } = require('./paths.cjs');
+const { readJsonSafe, writeJsonPretty, claudeSettingsLocalPath } = require('./claude-mcp.cjs');
+
+function readPluginManifest(installPath) {
+  try {
+    const manifest = readJsonSafe(path.join(installPath, '.claude-plugin', 'plugin.json'));
+    return {
+      name: typeof manifest.displayName === 'string' && manifest.displayName.trim()
+        ? manifest.displayName
+        : typeof manifest.name === 'string' ? manifest.name : undefined,
+      description: typeof manifest.description === 'string' ? manifest.description : undefined,
+    };
+  } catch {
+    return { name: undefined, description: undefined };
+  }
+}
+
+function listClaudePlugins(workspacePath, userHome) {
+  const installed = readJsonSafe(path.join(userHome, '.claude', 'plugins', 'installed_plugins.json'));
+  const plugins = installed.plugins && typeof installed.plugins === 'object' ? installed.plugins : {};
+  const globalEnabled = readJsonSafe(path.join(userHome, '.claude', 'settings.json')).enabledPlugins || {};
+  const projectEnabled = readJsonSafe(claudeSettingsLocalPath(workspacePath)).enabledPlugins || {};
+
+  return Object.keys(plugins)
+    .sort((a, b) => a.localeCompare(b))
+    .map((pluginId) => {
+      const installs = Array.isArray(plugins[pluginId]) ? plugins[pluginId] : [];
+      const install = installs[0] || {};
+      const manifest = install.installPath ? readPluginManifest(install.installPath) : {};
+      const enabled = projectEnabled[pluginId] ?? globalEnabled[pluginId] ?? true;
+      return {
+        id: pluginId,
+        name: manifest.name || pluginId,
+        description: manifest.description,
+        origin: 'plugin',
+        source: install.installPath ? displayPath(install.installPath, userHome) : pluginId,
+        enabled: Boolean(enabled),
+        toggleable: true,
+      };
+    });
+}
+
+function toggleClaudePlugin(workspacePath, userHome, id, enabled) {
+  const settingsPath = claudeSettingsLocalPath(workspacePath);
+  const settings = readJsonSafe(settingsPath);
+  const enabledPlugins = settings.enabledPlugins && typeof settings.enabledPlugins === 'object' ? { ...settings.enabledPlugins } : {};
+  enabledPlugins[id] = enabled;
+  settings.enabledPlugins = enabledPlugins;
+  writeJsonPretty(settingsPath, settings);
+  return listClaudePlugins(workspacePath, userHome).find((item) => item.id === id)
+    ?? { id, name: id, origin: 'plugin', source: id, enabled, toggleable: true };
+}
+
+module.exports = { listClaudePlugins, toggleClaudePlugin };