tlc-claude-code 1.8.5 → 2.1.0

package/server/lib/workspace-context.js

@@ -0,0 +1,129 @@
+/**
+ * Workspace Context Builder
+ *
+ * Combines workspace detection, memory inheritance, and CLAUDE.md cascade
+ * into a unified context object that TLC commands can consume.
+ *
+ * Factory function `createWorkspaceContext` accepts three injected dependencies:
+ *   - workspaceDetector  — detects if a project is in a workspace
+ *   - memoryInheritance  — loads inherited decisions/gotchas from workspace
+ *   - claudeCascade      — provides cascaded CLAUDE.md content
+ *
+ * The returned object exposes:
+ *   - buildContext(projectDir) — builds the full workspace context
+ *
+ * @module workspace-context
+ */
+
+/**
+ * Static token budget split between project and workspace context.
+ * @type {{ project: number, workspace: number }}
+ */
+const TOKEN_BUDGET = { project: 0.6, workspace: 0.4 };
+
+/**
+ * Format an array of memory items into a markdown list.
+ *
+ * @param {string} heading - Section heading (e.g. "Decisions")
+ * @param {Object[]} items - Memory items with topic and text properties
+ * @returns {string} Formatted markdown section, or empty string if no items
+ */
+function formatMemorySection(heading, items) {
+  if (!items || items.length === 0) return '';
+
+  const lines = [`### ${heading}`, ''];
+  for (const item of items) {
+    const label = item.topic || 'unknown';
+    const text = item.text || '';
+    lines.push(`- **${label}**: ${text}`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Create a workspace context builder instance.
+ *
+ * @param {Object} deps
+ * @param {Object} deps.workspaceDetector - Detector with detectWorkspace(dir)
+ * @param {Object} deps.memoryInheritance - Engine with loadInheritedMemory(dir)
+ * @param {Object} deps.claudeCascade - Cascade with getCascadedContext(dir)
+ * @returns {{ buildContext: (projectDir: string) => Promise<WorkspaceContext> }}
+ *
+ * @typedef {Object} WorkspaceContext
+ * @property {boolean} isInWorkspace - Whether the project is inside a workspace
+ * @property {string|null} workspaceSection - Markdown section for workspace context
+ * @property {Object[]} inheritedDecisions - Decisions inherited from workspace
+ * @property {Object[]} inheritedGotchas - Gotchas inherited from workspace
+ * @property {{ project: number, workspace: number }} tokenBudget - Token budget split
+ */
+export function createWorkspaceContext({ workspaceDetector, memoryInheritance, claudeCascade }) {
+  /**
+   * Build full workspace context for a project directory.
+   *
+   * Loads inherited memory, detects workspace status, and merges cascaded
+   * CLAUDE.md content into a single context object.
+   *
+   * @param {string} projectDir - Absolute path to the project directory
+   * @returns {Promise<WorkspaceContext>}
+   */
+  async function buildContext(projectDir) {
+    // Detect workspace
+    const wsResult = workspaceDetector.detectWorkspace(projectDir);
+    const isInWorkspace = wsResult.isInWorkspace;
+
+    // Load inherited memory
+    const memory = await memoryInheritance.loadInheritedMemory(projectDir);
+
+    const inheritedDecisions = memory.decisions || [];
+    const inheritedGotchas = memory.gotchas || [];
+
+    // For standalone projects, return minimal context
+    if (!isInWorkspace) {
+      return {
+        isInWorkspace: false,
+        workspaceSection: null,
+        inheritedDecisions,
+        inheritedGotchas,
+        tokenBudget: TOKEN_BUDGET,
+      };
+    }
+
+    // Get cascaded CLAUDE.md content
+    const cascadeResult = await claudeCascade.getCascadedContext(projectDir);
+
+    // Build workspace section as markdown
+    const sectionParts = ['## Workspace Context', ''];
+
+    // Include cascaded CLAUDE.md content
+    if (cascadeResult.workspaceContent) {
+      sectionParts.push(cascadeResult.workspaceContent.trim());
+      sectionParts.push('');
+    }
+
+    // Include inherited decisions
+    const decisionsSection = formatMemorySection('Inherited Decisions', inheritedDecisions);
+    if (decisionsSection) {
+      sectionParts.push(decisionsSection);
+      sectionParts.push('');
+    }
+
+    // Include inherited gotchas
+    const gotchasSection = formatMemorySection('Inherited Gotchas', inheritedGotchas);
+    if (gotchasSection) {
+      sectionParts.push(gotchasSection);
+      sectionParts.push('');
+    }
+
+    const workspaceSection = sectionParts.join('\n').trimEnd();
+
+    return {
+      isInWorkspace: true,
+      workspaceSection,
+      inheritedDecisions,
+      inheritedGotchas,
+      tokenBudget: TOKEN_BUDGET,
+    };
+  }
+
+  return { buildContext };
+}

package/server/lib/workspace-context.test.js

@@ -0,0 +1,214 @@
+/**
+ * Workspace Context Tests
+ *
+ * Tests for building workspace context that TLC commands can consume.
+ * Combines workspace detection, memory inheritance, and CLAUDE.md cascade
+ * into a unified context object.
+ *
+ * Dependencies are injected (workspaceDetector, memoryInheritance, claudeCascade)
+ * and fully mocked with vi.fn().
+ *
+ * These tests are written BEFORE the implementation (Red phase).
+ */
+
+import { describe, it, beforeEach, expect, vi } from 'vitest';
+import { createWorkspaceContext } from './workspace-context.js';
+
+// ---------------------------------------------------------------------------
+// Mock factories
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a mock workspaceDetector that reports being in a workspace.
+ * @param {boolean} isInWorkspace - Whether to simulate being in a workspace
+ * @returns {object} Mock detector with detectWorkspace stub
+ */
+function createMockDetector(isInWorkspace = true) {
+  return {
+    detectWorkspace: vi.fn().mockReturnValue({
+      isInWorkspace,
+      workspaceRoot: isInWorkspace ? '/workspace' : null,
+      projectPath: '/workspace/my-project',
+      relativeProjectPath: isInWorkspace ? 'my-project' : null,
+    }),
+  };
+}
+
+/**
+ * Creates a mock memoryInheritance engine.
+ * @param {object} memory - Memory to return from loadInheritedMemory
+ * @returns {object} Mock engine with loadInheritedMemory stub
+ */
+function createMockMemoryInheritance(memory = null) {
+  const defaultMemory = {
+    decisions: [
+      { topic: 'use-postgres', text: 'Use Postgres for JSONB support', source: 'workspace' },
+      { topic: 'rest-api', text: 'Use REST over GraphQL', source: 'workspace' },
+    ],
+    gotchas: [
+      { topic: 'auth-warmup', text: 'Auth service needs 2s warmup', source: 'workspace' },
+    ],
+    preferences: [],
+    conversations: [],
+  };
+
+  return {
+    loadInheritedMemory: vi.fn().mockResolvedValue(memory || defaultMemory),
+  };
+}
+
+/**
+ * Creates a mock claudeCascade.
+ * @param {object} context - Context to return from getCascadedContext
+ * @returns {object} Mock cascade with getCascadedContext stub
+ */
+function createMockCascade(context = null) {
+  const defaultContext = {
+    workspaceContent: '# Workspace\n\n## Coding Standards\n\nUse ESLint.\n',
+    projectContent: '# Project\n\nProject rules.\n',
+    merged: '<!-- TLC-WORKSPACE-START -->\n## Coding Standards\n\nUse ESLint.\n<!-- TLC-WORKSPACE-END -->\n\n# Project\n\nProject rules.\n',
+  };
+
+  return {
+    getCascadedContext: vi.fn().mockResolvedValue(context || defaultContext),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('workspace-context', () => {
+  let mockDetector;
+  let mockMemoryInheritance;
+  let mockCascade;
+  let wsContext;
+
+  beforeEach(() => {
+    mockDetector = createMockDetector(true);
+    mockMemoryInheritance = createMockMemoryInheritance();
+    mockCascade = createMockCascade();
+
+    wsContext = createWorkspaceContext({
+      workspaceDetector: mockDetector,
+      memoryInheritance: mockMemoryInheritance,
+      claudeCascade: mockCascade,
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 1. Session start loads inherited memory
+  // -------------------------------------------------------------------------
+  it('session start loads inherited memory (calls memoryInheritance.loadInheritedMemory)', async () => {
+    await wsContext.buildContext('/workspace/my-project');
+
+    expect(mockMemoryInheritance.loadInheritedMemory).toHaveBeenCalledWith(
+      '/workspace/my-project'
+    );
+  });
+
+  // -------------------------------------------------------------------------
+  // 2. Context includes "Workspace Context" section heading
+  // -------------------------------------------------------------------------
+  it('context includes "Workspace Context" section heading in workspaceSection', async () => {
+    const context = await wsContext.buildContext('/workspace/my-project');
+
+    expect(context.workspaceSection).toContain('## Workspace Context');
+  });
+
+  // -------------------------------------------------------------------------
+  // 3. Workspace decisions included in inheritedDecisions
+  // -------------------------------------------------------------------------
+  it('workspace decisions included in inheritedDecisions', async () => {
+    const context = await wsContext.buildContext('/workspace/my-project');
+
+    expect(context.inheritedDecisions).toHaveLength(2);
+    expect(context.inheritedDecisions[0]).toHaveProperty('topic', 'use-postgres');
+    expect(context.inheritedDecisions[1]).toHaveProperty('topic', 'rest-api');
+  });
+
+  // -------------------------------------------------------------------------
+  // 4. Workspace gotchas surfaced in inheritedGotchas
+  // -------------------------------------------------------------------------
+  it('workspace gotchas surfaced in inheritedGotchas', async () => {
+    const context = await wsContext.buildContext('/workspace/my-project');
+
+    expect(context.inheritedGotchas).toHaveLength(1);
+    expect(context.inheritedGotchas[0]).toHaveProperty('topic', 'auth-warmup');
+  });
+
+  // -------------------------------------------------------------------------
+  // 5. Token budget split: project=0.6, workspace=0.4
+  // -------------------------------------------------------------------------
+  it('token budget split: project=0.6, workspace=0.4', async () => {
+    const context = await wsContext.buildContext('/workspace/my-project');
+
+    expect(context.tokenBudget).toEqual({ project: 0.6, workspace: 0.4 });
+  });
+
+  // -------------------------------------------------------------------------
+  // 6. No workspace section for standalone projects
+  // -------------------------------------------------------------------------
+  it('no workspace section for standalone projects (workspaceSection is empty/null)', async () => {
+    const standaloneDetector = createMockDetector(false);
+    const standaloneMemory = createMockMemoryInheritance({
+      decisions: [],
+      gotchas: [],
+      preferences: [],
+      conversations: [],
+    });
+    const standaloneCascade = createMockCascade({
+      workspaceContent: null,
+      projectContent: '# Project\n',
+      merged: '# Project\n',
+    });
+
+    const standalone = createWorkspaceContext({
+      workspaceDetector: standaloneDetector,
+      memoryInheritance: standaloneMemory,
+      claudeCascade: standaloneCascade,
+    });
+
+    const context = await standalone.buildContext('/standalone-project');
+
+    expect(context.isInWorkspace).toBe(false);
+    expect(context.workspaceSection).toBeFalsy();
+  });
+
+  // -------------------------------------------------------------------------
+  // 7. Handles missing workspace memory gracefully (empty arrays)
+  // -------------------------------------------------------------------------
+  it('handles missing workspace memory gracefully (empty arrays)', async () => {
+    const emptyMemory = createMockMemoryInheritance({
+      decisions: [],
+      gotchas: [],
+      preferences: [],
+      conversations: [],
+    });
+
+    const ctx = createWorkspaceContext({
+      workspaceDetector: mockDetector,
+      memoryInheritance: emptyMemory,
+      claudeCascade: mockCascade,
+    });
+
+    const context = await ctx.buildContext('/workspace/my-project');
+
+    expect(context.inheritedDecisions).toEqual([]);
+    expect(context.inheritedGotchas).toEqual([]);
+    expect(context.isInWorkspace).toBe(true);
+  });
+
+  // -------------------------------------------------------------------------
+  // 8. Workspace context includes cascaded CLAUDE.md content
+  // -------------------------------------------------------------------------
+  it('workspace context includes cascaded CLAUDE.md content', async () => {
+    const context = await wsContext.buildContext('/workspace/my-project');
+
+    expect(mockCascade.getCascadedContext).toHaveBeenCalledWith(
+      '/workspace/my-project'
+    );
+    // The workspaceSection should include content from the cascade
+    expect(context.workspaceSection).toContain('Use ESLint');
+  });
+});

package/server/lib/workspace-detector.js

@@ -0,0 +1,162 @@
+/**
+ * Workspace Detector
+ *
+ * Detects when the current project is inside a TLC workspace by walking up
+ * the directory tree looking for workspace markers:
+ *   - projects.json file
+ *   - .tlc.json with "workspace": true
+ *   - memory/ directory
+ *
+ * @module workspace-detector
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+/**
+ * Check whether a directory contains any workspace marker.
+ *
+ * Markers (checked in order):
+ *   1. projects.json file
+ *   2. .tlc.json with { "workspace": true }
+ *   3. memory/ directory
+ *
+ * @param {string} dir - Absolute path to check
+ * @returns {boolean} true if the directory is a workspace root
+ */
+function hasWorkspaceMarker(dir) {
+  // Marker 1: projects.json
+  try {
+    const pj = path.join(dir, 'projects.json');
+    if (fs.statSync(pj).isFile()) return true;
+  } catch { /* not found */ }
+
+  // Marker 2: .tlc.json with workspace: true
+  try {
+    const tlcPath = path.join(dir, '.tlc.json');
+    if (fs.statSync(tlcPath).isFile()) {
+      const content = fs.readFileSync(tlcPath, 'utf8');
+      const json = JSON.parse(content);
+      if (json && json.workspace === true) return true;
+    }
+  } catch { /* not found or invalid json */ }
+
+  // Marker 3: memory/ directory
+  try {
+    const memDir = path.join(dir, 'memory');
+    if (fs.statSync(memDir).isDirectory()) return true;
+  } catch { /* not found */ }
+
+  return false;
+}
+
+/**
+ * Create a workspace detector instance.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.boundary] - Stop walking at this directory (exclusive).
+ *   Defaults to os.homedir()'s parent.  The detector will never walk above
+ *   os.homedir() regardless of this setting.
+ * @returns {{ detectWorkspace: (projectDir: string) => WorkspaceResult }}
+ *
+ * @typedef {Object} WorkspaceResult
+ * @property {boolean} isInWorkspace
+ * @property {string|null} workspaceRoot
+ * @property {string} projectPath
+ * @property {string|null} relativeProjectPath
+ */
+export function createWorkspaceDetector(options = {}) {
+  const cache = new Map();
+  const homeDir = os.homedir();
+  const boundary = options.boundary || null;
+
+  /**
+   * Detect whether `projectDir` lives inside a workspace.
+   *
+   * Walks from `projectDir` upward, checking each directory for workspace
+   * markers.  Stops at the first match (nearest parent wins), or when it
+   * reaches the home directory, filesystem root, or the configured boundary.
+   *
+   * @param {string} projectDir - Absolute path to the project directory
+   * @returns {WorkspaceResult}
+   */
+  function detectWorkspace(projectDir) {
+    const resolved = path.resolve(projectDir);
+
+    if (cache.has(resolved)) {
+      return cache.get(resolved);
+    }
+
+    let result;
+
+    // Check the project dir itself first
+    if (hasWorkspaceMarker(resolved)) {
+      result = {
+        isInWorkspace: true,
+        workspaceRoot: resolved,
+        projectPath: resolved,
+        relativeProjectPath: '.',
+      };
+      cache.set(resolved, result);
+      return result;
+    }
+
+    // Walk upward
+    let current = path.dirname(resolved);
+
+    while (true) {
+      // Stop conditions
+      // 1. Hit boundary (the boundary dir itself is NOT scanned)
+      if (boundary && current === path.resolve(boundary)) {
+        break;
+      }
+
+      // 2. Walked above home directory
+      if (homeDir && !current.startsWith(homeDir) && resolved.startsWith(homeDir)) {
+        break;
+      }
+
+      // 3. Hit filesystem root (path.dirname returns itself)
+      if (current === path.dirname(current)) {
+        // Check the root itself before giving up
+        if (hasWorkspaceMarker(current)) {
+          result = {
+            isInWorkspace: true,
+            workspaceRoot: current,
+            projectPath: resolved,
+            relativeProjectPath: path.relative(current, resolved),
+          };
+          cache.set(resolved, result);
+          return result;
+        }
+        break;
+      }
+
+      if (hasWorkspaceMarker(current)) {
+        result = {
+          isInWorkspace: true,
+          workspaceRoot: current,
+          projectPath: resolved,
+          relativeProjectPath: path.relative(current, resolved),
+        };
+        cache.set(resolved, result);
+        return result;
+      }
+
+      current = path.dirname(current);
+    }
+
+    // No workspace found
+    result = {
+      isInWorkspace: false,
+      workspaceRoot: null,
+      projectPath: resolved,
+      relativeProjectPath: null,
+    };
+    cache.set(resolved, result);
+    return result;
+  }
+
+  return { detectWorkspace };
+}

package/server/lib/workspace-detector.test.js

@@ -0,0 +1,193 @@
+/**
+ * Workspace Detector Tests
+ *
+ * Tests for detecting when a project is inside a TLC workspace.
+ * Uses temp directories with actual marker files.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+/** Create a unique temp directory for each test */
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ws-detect-'));
+}
+
+/** Recursively remove a directory */
+function rmDir(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+describe('WorkspaceDetector', () => {
+  let tmpDir;
+  let createWorkspaceDetector;
+
+  beforeEach(async () => {
+    tmpDir = makeTmpDir();
+    const mod = await import('./workspace-detector.js');
+    createWorkspaceDetector = mod.createWorkspaceDetector;
+  });
+
+  afterEach(() => {
+    if (tmpDir) rmDir(tmpDir);
+  });
+
+  it('detects workspace when projects.json exists in parent directory', () => {
+    // workspace/
+    //   projects.json
+    //   my-project/
+    const wsRoot = tmpDir;
+    const projectDir = path.join(wsRoot, 'my-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.writeFileSync(path.join(wsRoot, 'projects.json'), '{}');
+
+    const detector = createWorkspaceDetector();
+    const result = detector.detectWorkspace(projectDir);
+
+    expect(result.isInWorkspace).toBe(true);
+    expect(result.workspaceRoot).toBe(wsRoot);
+    expect(result.projectPath).toBe(projectDir);
+  });
+
+  it('detects workspace when parent has .tlc.json with workspace: true', () => {
+    // workspace/
+    //   .tlc.json  (contains "workspace": true)
+    //   my-project/
+    const wsRoot = tmpDir;
+    const projectDir = path.join(wsRoot, 'my-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(wsRoot, '.tlc.json'),
+      JSON.stringify({ workspace: true })
+    );
+
+    const detector = createWorkspaceDetector();
+    const result = detector.detectWorkspace(projectDir);
+
+    expect(result.isInWorkspace).toBe(true);
+    expect(result.workspaceRoot).toBe(wsRoot);
+  });
+
+  it('detects workspace when parent has memory/ directory', () => {
+    // workspace/
+    //   memory/
+    //   my-project/
+    const wsRoot = tmpDir;
+    const projectDir = path.join(wsRoot, 'my-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.mkdirSync(path.join(wsRoot, 'memory'), { recursive: true });
+
+    const detector = createWorkspaceDetector();
+    const result = detector.detectWorkspace(projectDir);
+
+    expect(result.isInWorkspace).toBe(true);
+    expect(result.workspaceRoot).toBe(wsRoot);
+  });
+
+  it('returns isInWorkspace=false for standalone project', () => {
+    // standalone-project/   (no markers in any parent up to tmpDir)
+    const projectDir = path.join(tmpDir, 'standalone-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+
+    // Pass a boundary so we don't walk past tmpDir into real filesystem
+    const detector = createWorkspaceDetector({ boundary: tmpDir });
+    const result = detector.detectWorkspace(projectDir);
+
+    expect(result.isInWorkspace).toBe(false);
+    expect(result.workspaceRoot).toBeNull();
+    expect(result.projectPath).toBe(projectDir);
+    expect(result.relativeProjectPath).toBeNull();
+  });
+
+  it('stops at home directory (does not scan above os.homedir())', () => {
+    // By default, the detector should not walk above os.homedir().
+    // We test this by verifying the detector respects a boundary.
+    // Since we can't create dirs above home, we simulate with boundary option.
+    const homeDir = os.homedir();
+    const detector = createWorkspaceDetector();
+
+    // The real homedir may or may not be in a workspace - we just verify
+    // the detector does not throw and returns a valid shape
+    const result = detector.detectWorkspace(homeDir);
+    expect(result).toHaveProperty('isInWorkspace');
+    expect(result).toHaveProperty('workspaceRoot');
+    expect(result).toHaveProperty('projectPath');
+    expect(result).toHaveProperty('relativeProjectPath');
+  });
+
+  it('stops at filesystem root', () => {
+    // Pass the filesystem root. Should not throw or loop infinitely.
+    const detector = createWorkspaceDetector();
+    const result = detector.detectWorkspace('/');
+
+    expect(result.isInWorkspace).toBe(false);
+    expect(result.workspaceRoot).toBeNull();
+    expect(result.projectPath).toBe('/');
+  });
+
+  it('caches result across calls (same input returns same object)', () => {
+    const wsRoot = tmpDir;
+    const projectDir = path.join(wsRoot, 'cached-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.writeFileSync(path.join(wsRoot, 'projects.json'), '{}');
+
+    const detector = createWorkspaceDetector();
+    const first = detector.detectWorkspace(projectDir);
+    const second = detector.detectWorkspace(projectDir);
+
+    // Same reference - not just equal, but identical object
+    expect(first).toBe(second);
+  });
+
+  it('handles nested workspaces (nearest parent wins)', () => {
+    // outer-workspace/
+    //   projects.json
+    //   inner-workspace/
+    //     projects.json
+    //     my-project/
+    const outerWs = tmpDir;
+    const innerWs = path.join(outerWs, 'inner-workspace');
+    const projectDir = path.join(innerWs, 'my-project');
+
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.writeFileSync(path.join(outerWs, 'projects.json'), '{}');
+    fs.writeFileSync(path.join(innerWs, 'projects.json'), '{}');
+
+    const detector = createWorkspaceDetector();
+    const result = detector.detectWorkspace(projectDir);
+
+    expect(result.isInWorkspace).toBe(true);
+    // Nearest parent (inner) should win
+    expect(result.workspaceRoot).toBe(innerWs);
+  });
+
+  it('returns correct relative project path', () => {
+    const wsRoot = tmpDir;
+    const projectDir = path.join(wsRoot, 'apps', 'my-project');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.writeFileSync(path.join(wsRoot, 'projects.json'), '{}');
+
+    const detector = createWorkspaceDetector();
+    const result = detector.detectWorkspace(projectDir);
+
+    expect(result.isInWorkspace).toBe(true);
+    expect(result.relativeProjectPath).toBe(path.join('apps', 'my-project'));
+    expect(result.projectPath).toBe(projectDir);
+  });
+
+  it('works when project IS the workspace root itself', () => {
+    // The project dir itself has workspace markers
+    const projectDir = tmpDir;
+    fs.writeFileSync(path.join(projectDir, 'projects.json'), '{}');
+
+    const detector = createWorkspaceDetector();
+    const result = detector.detectWorkspace(projectDir);
+
+    expect(result.isInWorkspace).toBe(true);
+    expect(result.workspaceRoot).toBe(projectDir);
+    expect(result.projectPath).toBe(projectDir);
+    expect(result.relativeProjectPath).toBe('.');
+  });
+});