tlc-claude-code 2.0.1 → 2.1.0

package/server/lib/nginx-config.js

@@ -0,0 +1,114 @@
+/**
+ * Nginx Config Generator — server blocks, wildcard routing, SSL
+ * Phase 80 Task 5 (replaces caddy-config.js)
+ */
+
+const { isValidDomain } = require('./input-sanitizer.js');
+
+/**
+ * Generate Nginx site config for a project
+ * @param {Object} options
+ * @param {string} options.domain - Server domain
+ * @param {number} options.port - App port
+ * @param {string} options.proxyPass - Upstream URL
+ * @returns {string} Nginx config
+ */
+function generateSiteConfig({ domain, port, proxyPass }) {
+  if (!isValidDomain(domain)) throw new Error(`Invalid domain: ${domain}`);
+  return `# TLC generated Nginx config for ${domain}
+server {
+    listen 80;
+    server_name ${domain};
+
+    location / {
+        proxy_pass ${proxyPass};
+
+        # Proxy headers
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        # WebSocket support
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+
+        # Timeouts
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+    }
+}
+`;
+}
+
+/**
+ * Generate wildcard Nginx config for branch previews
+ * @param {string} baseDomain - Base domain (e.g. myapp.dev)
+ * @param {Object} options
+ * @param {Array} [options.branches] - [{ subdomain, port }]
+ * @returns {string} Nginx config
+ */
+function generateWildcardConfig(baseDomain, options = {}) {
+  if (!isValidDomain(baseDomain)) throw new Error(`Invalid domain: ${baseDomain}`);
+  const branches = options.branches || [];
+
+  // Map blocks for each branch
+  const mapEntries = branches
+    .map(b => `        ${b.subdomain}.${baseDomain} 127.0.0.1:${b.port};`)
+    .join('\n');
+
+  return `# TLC wildcard config for *.${baseDomain}
+
+map $host $branch_upstream {
+    default "";
+${mapEntries}
+}
+
+# Default server for unknown subdomains
+server {
+    listen 80 default_server;
+    server_name *.${baseDomain};
+
+    location / {
+        if ($branch_upstream = "") {
+            return 404 "No deployment for this branch";
+        }
+        proxy_pass http://$branch_upstream;
+
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}
+`;
+}
+
+/**
+ * Generate SSL config snippet for a domain
+ * @param {string} domain
+ * @returns {string} SSL config lines
+ */
+function generateSslConfig(domain) {
+  if (!isValidDomain(domain)) throw new Error(`Invalid domain: ${domain}`);
+  return `    # SSL Configuration for ${domain}
+    listen 443 ssl;
+    ssl_certificate /etc/letsencrypt/live/${domain}/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/${domain}/privkey.pem;
+
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_prefer_server_ciphers on;
+    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
+
+    # HSTS
+    add_header Strict-Transport-Security "max-age=63072000" always;
+`;
+}
+
+module.exports = { generateSiteConfig, generateWildcardConfig, generateSslConfig };

package/server/lib/nginx-config.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+
+const { generateSiteConfig, generateWildcardConfig, generateSslConfig } = await import('./nginx-config.js');
+
+describe('Nginx Config Generator', () => {
+  describe('generateSiteConfig', () => {
+    it('produces valid Nginx server block', () => {
+      const config = generateSiteConfig({
+        domain: 'myapp.dev',
+        port: 3000,
+        proxyPass: 'http://127.0.0.1:3000',
+      });
+      expect(config).toContain('server {');
+      expect(config).toContain('server_name myapp.dev');
+      expect(config).toContain('proxy_pass http://127.0.0.1:3000');
+    });
+
+    it('includes proxy headers', () => {
+      const config = generateSiteConfig({
+        domain: 'myapp.dev',
+        port: 3000,
+        proxyPass: 'http://127.0.0.1:3000',
+      });
+      expect(config).toContain('proxy_set_header Host');
+      expect(config).toContain('proxy_set_header X-Real-IP');
+      expect(config).toContain('proxy_set_header X-Forwarded-For');
+    });
+
+    it('includes WebSocket upgrade headers', () => {
+      const config = generateSiteConfig({
+        domain: 'myapp.dev',
+        port: 3000,
+        proxyPass: 'http://127.0.0.1:3000',
+      });
+      expect(config).toContain('proxy_http_version 1.1');
+      expect(config).toContain('Upgrade');
+      expect(config).toContain('Connection');
+    });
+
+    it('listens on port 80 by default', () => {
+      const config = generateSiteConfig({
+        domain: 'myapp.dev',
+        port: 3000,
+        proxyPass: 'http://127.0.0.1:3000',
+      });
+      expect(config).toContain('listen 80');
+    });
+  });
+
+  describe('generateWildcardConfig', () => {
+    it('routes subdomains to container ports', () => {
+      const config = generateWildcardConfig('myapp.dev', {
+        branches: [
+          { subdomain: 'feat-login', port: 4001 },
+          { subdomain: 'main', port: 4000 },
+        ],
+      });
+      expect(config).toContain('*.myapp.dev');
+      expect(config).toContain('feat-login');
+      expect(config).toContain('4001');
+    });
+
+    it('includes default server for unknown subdomains', () => {
+      const config = generateWildcardConfig('myapp.dev', { branches: [] });
+      expect(config).toContain('default_server');
+    });
+  });
+
+  describe('generateSslConfig', () => {
+    it('references Lets Encrypt certificate paths', () => {
+      const config = generateSslConfig('myapp.dev');
+      expect(config).toContain('ssl_certificate');
+      expect(config).toContain('/etc/letsencrypt');
+      expect(config).toContain('myapp.dev');
+    });
+
+    it('includes SSL security settings', () => {
+      const config = generateSslConfig('myapp.dev');
+      expect(config).toContain('ssl_protocols');
+    });
+  });
+});

package/server/lib/ollama-health.js

@@ -0,0 +1,91 @@
+/**
+ * Ollama health checker.
+ *
+ * Checks whether Ollama is installed, running, and has the required
+ * embedding model. Returns actionable messages for each failure state.
+ * Results are cached for 60 seconds.
+ *
+ * @module ollama-health
+ */
+
+const OLLAMA_URL = process.env.OLLAMA_URL || 'http://localhost:11434';
+const REQUIRED_MODEL = 'mxbai-embed-large';
+const CACHE_TTL_MS = 60 * 1000;
+
+/** @enum {string} */
+const OLLAMA_STATUS = {
+  READY: 'ready',
+  NOT_INSTALLED: 'not_installed',
+  NOT_RUNNING: 'not_running',
+  NO_MODEL: 'no_model',
+};
+
+let cachedResult = null;
+let cachedAt = 0;
+
+/**
+ * Check Ollama health status.
+ *
+ * @param {object} [deps] - Injectable dependencies for testing
+ * @param {Function} [deps.fetch] - Fetch implementation
+ * @returns {Promise<{status: string, message: string, action: string}>}
+ */
+async function checkOllamaHealth(deps = {}) {
+  const now = Date.now();
+  if (cachedResult && (now - cachedAt) < CACHE_TTL_MS) {
+    return cachedResult;
+  }
+
+  const fetchFn = deps.fetch || globalThis.fetch;
+
+  try {
+    const response = await fetchFn(`${OLLAMA_URL}/api/tags`, {
+      signal: AbortSignal.timeout(3000),
+    });
+
+    if (!response.ok) {
+      cachedResult = {
+        status: OLLAMA_STATUS.NOT_RUNNING,
+        message: 'Ollama responded with an error',
+        action: 'Restart Ollama: ollama serve',
+      };
+      cachedAt = now;
+      return cachedResult;
+    }
+
+    const data = await response.json();
+    const models = data.models || [];
+    const hasModel = models.some(m => m.name && m.name.startsWith(REQUIRED_MODEL));
+
+    if (hasModel) {
+      cachedResult = {
+        status: OLLAMA_STATUS.READY,
+        message: 'Memory: full (pattern detection + semantic search)',
+        action: '',
+      };
+    } else {
+      cachedResult = {
+        status: OLLAMA_STATUS.NO_MODEL,
+        message: `Ollama running but ${REQUIRED_MODEL} model not found`,
+        action: `ollama pull ${REQUIRED_MODEL}`,
+      };
+    }
+  } catch {
+    cachedResult = {
+      status: OLLAMA_STATUS.NOT_RUNNING,
+      message: 'Ollama not running. Semantic search disabled, pattern detection still works.',
+      action: 'brew install ollama && ollama serve && ollama pull mxbai-embed-large',
+    };
+  }
+
+  cachedAt = now;
+  return cachedResult;
+}
+
+/** Clear the cache (for testing). */
+checkOllamaHealth._clearCache = function () {
+  cachedResult = null;
+  cachedAt = 0;
+};
+
+module.exports = { checkOllamaHealth, OLLAMA_STATUS };

package/server/lib/ollama-health.test.js

@@ -0,0 +1,74 @@
+/**
+ * Ollama health checker tests - Phase 84 Task 1
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+import { checkOllamaHealth, OLLAMA_STATUS } from './ollama-health.js';
+
+describe('ollama-health', () => {
+  beforeEach(() => {
+    // Clear cache between tests
+    checkOllamaHealth._clearCache?.();
+  });
+
+  it('returns ready when Ollama responds with correct model', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ models: [{ name: 'mxbai-embed-large:latest' }] }),
+    });
+
+    const result = await checkOllamaHealth({ fetch: mockFetch });
+    expect(result.status).toBe(OLLAMA_STATUS.READY);
+    expect(result.message).toContain('full');
+  });
+
+  it('returns not_running when connection refused', async () => {
+    const mockFetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+
+    const result = await checkOllamaHealth({ fetch: mockFetch });
+    expect([OLLAMA_STATUS.NOT_INSTALLED, OLLAMA_STATUS.NOT_RUNNING]).toContain(result.status);
+    expect(result.action).toBeDefined();
+  });
+
+  it('returns no_model when Ollama responds but model missing', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ models: [{ name: 'llama3:latest' }] }),
+    });
+
+    const result = await checkOllamaHealth({ fetch: mockFetch });
+    expect(result.status).toBe(OLLAMA_STATUS.NO_MODEL);
+    expect(result.action).toContain('ollama pull');
+  });
+
+  it('caches result within 60s window', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ models: [{ name: 'mxbai-embed-large:latest' }] }),
+    });
+
+    const result1 = await checkOllamaHealth({ fetch: mockFetch });
+    const result2 = await checkOllamaHealth({ fetch: mockFetch });
+
+    expect(result1.status).toBe(result2.status);
+    // Should only call fetch once due to caching
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns actionable message for each status', async () => {
+    const mockFetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+
+    const result = await checkOllamaHealth({ fetch: mockFetch });
+    expect(result.action).toBeTruthy();
+    expect(typeof result.action).toBe('string');
+    expect(result.message).toBeTruthy();
+  });
+
+  it('exports status constants', () => {
+    expect(OLLAMA_STATUS.READY).toBe('ready');
+    expect(OLLAMA_STATUS.NOT_INSTALLED).toBe('not_installed');
+    expect(OLLAMA_STATUS.NOT_RUNNING).toBe('not_running');
+    expect(OLLAMA_STATUS.NO_MODEL).toBe('no_model');
+  });
+});

package/server/lib/port-guard.js

@@ -0,0 +1,44 @@
+/**
+ * Port guard - checks if a port is available before server startup.
+ *
+ * Detects port conflicts and reports which process holds the port.
+ * Designed for use with launchd ThrottleInterval to prevent restart spam.
+ *
+ * @module port-guard
+ */
+
+const net = require('net');
+
+/**
+ * Check if a port is available.
+ *
+ * @param {number} port - Port number to check
+ * @returns {Promise<{available: boolean, port: number, pid?: number, command?: string}>}
+ */
+async function checkPort(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve({ available: false, port });
+      } else {
+        // Unexpected error — treat as unavailable
+        resolve({ available: false, port });
+      }
+    });
+
+    server.once('listening', () => {
+      // Port is free — close the test server
+      const addr = server.address();
+      const actualPort = addr ? addr.port : port;
+      server.close(() => {
+        resolve({ available: true, port: actualPort });
+      });
+    });
+
+    server.listen(port);
+  });
+}
+
+module.exports = { checkPort };

package/server/lib/port-guard.test.js

@@ -0,0 +1,65 @@
+/**
+ * Port guard tests - Phase 83 Task 2
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import net from 'net';
+
+import { checkPort } from './port-guard.js';
+
+describe('port-guard', () => {
+  let tempServer;
+
+  afterEach(() => {
+    if (tempServer) {
+      tempServer.close();
+      tempServer = null;
+    }
+  });
+
+  it('returns available:true when port is free', async () => {
+    // Use a high ephemeral port unlikely to be in use
+    const result = await checkPort(0);
+    expect(result.available).toBe(true);
+  });
+
+  it('returns available:false when port is occupied', async () => {
+    // Occupy a port first
+    tempServer = net.createServer();
+    await new Promise((resolve, reject) => {
+      tempServer.listen(0, resolve);
+      tempServer.on('error', reject);
+    });
+    const port = tempServer.address().port;
+
+    const result = await checkPort(port);
+    expect(result.available).toBe(false);
+  });
+
+  it('includes pid info when port is occupied (best effort)', async () => {
+    tempServer = net.createServer();
+    await new Promise((resolve, reject) => {
+      tempServer.listen(0, resolve);
+      tempServer.on('error', reject);
+    });
+    const port = tempServer.address().port;
+
+    const result = await checkPort(port);
+    expect(result.available).toBe(false);
+    // pid is best-effort (may not be available on all platforms)
+    expect(result).toHaveProperty('port', port);
+  });
+
+  it('handles EADDRINUSE gracefully', async () => {
+    tempServer = net.createServer();
+    await new Promise((resolve, reject) => {
+      tempServer.listen(0, resolve);
+      tempServer.on('error', reject);
+    });
+    const port = tempServer.address().port;
+
+    // Should not throw
+    const result = await checkPort(port);
+    expect(result.available).toBe(false);
+  });
+});

package/server/lib/project-scanner.js

@@ -109,9 +109,11 @@ function readProjectMetadata(projectDir) {
   const hasTlc = fs.existsSync(path.join(projectDir, '.tlc.json'));
   const hasPlanning = fs.existsSync(path.join(projectDir, '.planning'));
 
-  // Read name and version from package.json if present
+  // Read name, version, and workspaces from package.json if present
   let name = path.basename(projectDir);
   let version = null;
+  let isMonorepo = false;
+  let workspaces = [];
 
   const pkgPath = path.join(projectDir, 'package.json');
   if (fs.existsSync(pkgPath)) {
@@ -123,6 +125,34 @@ function readProjectMetadata(projectDir) {
       if (pkg.version) {
         version = pkg.version;
       }
+
+      // Detect monorepo workspaces (npm array or yarn object format)
+      let workspacePatterns = null;
+      if (Array.isArray(pkg.workspaces)) {
+        workspacePatterns = pkg.workspaces;
+      } else if (pkg.workspaces && Array.isArray(pkg.workspaces.packages)) {
+        workspacePatterns = pkg.workspaces.packages;
+      }
+
+      if (workspacePatterns) {
+        isMonorepo = true;
+        // Resolve glob patterns to actual directories
+        for (const pattern of workspacePatterns) {
+          try {
+            const globDir = path.join(projectDir, path.dirname(pattern));
+            if (fs.existsSync(globDir)) {
+              const entries = fs.readdirSync(globDir, { withFileTypes: true });
+              for (const entry of entries) {
+                if (entry.isDirectory()) {
+                  workspaces.push(path.join(path.dirname(pattern), entry.name));
+                }
+              }
+            }
+          } catch {
+            // Ignore glob resolution errors
+          }
+        }
+      }
     } catch {
       // Ignore malformed package.json
     }
@@ -147,6 +177,8 @@ function readProjectMetadata(projectDir) {
     phaseName: phaseInfo.phaseName,
     totalPhases: phaseInfo.totalPhases,
     completedPhases: phaseInfo.completedPhases,
+    isMonorepo,
+    workspaces,
   };
 }
 
@@ -235,9 +267,12 @@ class ProjectScanner {
       if (typeof onProgress === 'function') {
         onProgress(projectsByPath.size);
       }
+
+      // Stop recursion: a project's children are not separate projects
+      return;
     }
 
-    // Recurse into subdirectories
+    // Recurse into subdirectories (only for non-project directories)
     let entries;
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });

package/server/lib/project-scanner.test.js

@@ -386,4 +386,156 @@ describe('ProjectScanner', () => {
     // The last reported count should match total found
     expect(progressCounts[progressCounts.length - 1]).toBe(2);
   });
+
+  // =========================================================================
+  // Phase 79 — Task 1: Stop recursion at project boundaries
+  // =========================================================================
+
+  // Test 20: Does NOT recurse into subdirectories of a detected project
+  it('does not recurse into subdirectories of a detected project', () => {
+    // Create a TLC project with a nested sub-package that also looks like a project
+    const projectDir = createTlcProject(tempDir, 'monorepo-project');
+    const subPkgDir = path.join(projectDir, 'packages', 'sub-package');
+    fs.mkdirSync(subPkgDir, { recursive: true });
+    fs.writeFileSync(path.join(subPkgDir, 'package.json'), JSON.stringify({ name: 'sub-package' }));
+    fs.mkdirSync(path.join(subPkgDir, '.git'), { recursive: true });
+
+    const results = scanner.scan([tempDir]);
+
+    // Should only find the parent project, not the sub-package
+    expect(results).toHaveLength(1);
+    expect(results[0].name).toBe('monorepo-project');
+  });
+
+  // Test 21: TLC project's server/ subdirectory not listed separately
+  it('does not list subdirectories of a TLC project as separate projects', () => {
+    const projectDir = createTlcProject(tempDir, 'tlc-project');
+    // Create a server/ subdirectory with its own package.json + .git
+    const serverDir = path.join(projectDir, 'server');
+    fs.mkdirSync(serverDir, { recursive: true });
+    fs.writeFileSync(path.join(serverDir, 'package.json'), JSON.stringify({ name: 'tlc-server' }));
+    fs.mkdirSync(path.join(serverDir, '.git'), { recursive: true });
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].name).toBe('tlc-project');
+  });
+
+  // Test 22: Top-level non-project directories are still traversed
+  it('still traverses non-project directories to find nested projects', () => {
+    // Create a plain directory (not a project) with a project nested inside
+    const groupDir = path.join(tempDir, 'my-workspace');
+    fs.mkdirSync(groupDir, { recursive: true });
+    // No .tlc.json, no .planning, no package.json+.git — just a folder
+    createTlcProject(groupDir, 'nested-real-project');
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].name).toBe('nested-real-project');
+  });
+
+  // Test 23: Multiple projects at same level, none recurse into children
+  it('finds sibling projects but does not recurse into either', () => {
+    const projA = createTlcProject(tempDir, 'project-a');
+    const projB = createTlcProject(tempDir, 'project-b');
+
+    // Add nested sub-projects inside each
+    const nestedA = path.join(projA, 'nested');
+    fs.mkdirSync(nestedA, { recursive: true });
+    fs.writeFileSync(path.join(nestedA, '.tlc.json'), '{}');
+
+    const nestedB = path.join(projB, 'apps', 'frontend');
+    fs.mkdirSync(nestedB, { recursive: true });
+    fs.writeFileSync(path.join(nestedB, 'package.json'), JSON.stringify({ name: 'frontend' }));
+    fs.mkdirSync(path.join(nestedB, '.git'), { recursive: true });
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(2);
+    const names = results.map(r => r.name);
+    expect(names).toContain('project-a');
+    expect(names).toContain('project-b');
+  });
+
+  // =========================================================================
+  // Phase 79 — Task 2: Monorepo sub-package metadata
+  // =========================================================================
+
+  // Test 24: Detects npm workspaces array format
+  it('detects npm workspaces and returns isMonorepo: true', () => {
+    createTlcProject(tempDir, 'npm-monorepo', {
+      packageJson: {
+        name: 'npm-monorepo',
+        version: '1.0.0',
+        workspaces: ['packages/*'],
+      },
+    });
+
+    // Create a matching sub-package directory
+    const pkgDir = path.join(tempDir, 'npm-monorepo', 'packages', 'core');
+    fs.mkdirSync(pkgDir, { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, 'package.json'), JSON.stringify({ name: '@mono/core' }));
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isMonorepo).toBe(true);
+    expect(results[0].workspaces).toBeInstanceOf(Array);
+    expect(results[0].workspaces.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // Test 25: Detects yarn workspaces object format
+  it('detects yarn workspaces object format', () => {
+    createTlcProject(tempDir, 'yarn-monorepo', {
+      packageJson: {
+        name: 'yarn-monorepo',
+        version: '1.0.0',
+        workspaces: { packages: ['packages/*'] },
+      },
+    });
+
+    const pkgDir = path.join(tempDir, 'yarn-monorepo', 'packages', 'utils');
+    fs.mkdirSync(pkgDir, { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, 'package.json'), JSON.stringify({ name: '@mono/utils' }));
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isMonorepo).toBe(true);
+    expect(results[0].workspaces).toBeInstanceOf(Array);
+    expect(results[0].workspaces.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // Test 26: Non-monorepo returns isMonorepo: false and empty workspaces
+  it('returns isMonorepo false and empty workspaces for regular project', () => {
+    createTlcProject(tempDir, 'regular-project', {
+      packageJson: { name: 'regular-project', version: '1.0.0' },
+    });
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isMonorepo).toBe(false);
+    expect(results[0].workspaces).toEqual([]);
+  });
+
+  // Test 27: Monorepo with no matching workspace directories
+  it('returns empty workspaces when glob pattern matches nothing', () => {
+    createTlcProject(tempDir, 'empty-mono', {
+      packageJson: {
+        name: 'empty-mono',
+        version: '1.0.0',
+        workspaces: ['packages/*'],
+      },
+    });
+    // Don't create the packages/ directory at all
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isMonorepo).toBe(true);
+    expect(results[0].workspaces).toEqual([]);
+  });
 });