worclaude 2.5.0 → 2.6.0

package/src/core/project-scanner/detectors/monorepo.js

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import YAML from 'yaml';
+import fs from 'fs-extra';
+import { fileExists, readFile } from '../../../utils/file.js';
+import { readPackageJson } from '../manifests.js';
+
+async function readYamlWorkspacePackages(projectRoot) {
+  const filePath = path.join(projectRoot, 'pnpm-workspace.yaml');
+  if (!(await fileExists(filePath))) return null;
+  try {
+    const raw = await readFile(filePath);
+    const parsed = YAML.parse(raw);
+    if (parsed && Array.isArray(parsed.packages)) return parsed.packages;
+  } catch {
+    /* missing or unreadable — non-fatal */
+  }
+  return null;
+}
+
+async function expandPackagePaths(projectRoot, patterns) {
+  const paths = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith('/*')) {
+      const parent = pattern.slice(0, -2);
+      const parentPath = path.join(projectRoot, parent);
+      try {
+        const entries = await fs.readdir(parentPath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) paths.push(path.posix.join(parent, entry.name));
+        }
+      } catch {
+        // directory missing — pnpm-workspace.yaml lists a path the user hasn't created
+      }
+    } else {
+      paths.push(pattern);
+    }
+  }
+  return paths;
+}
+
+export default async function detectMonorepo(projectRoot) {
+  const results = [];
+  const sources = [];
+  let packagePaths = [];
+  let tool = null;
+
+  const pnpmPackages = await readYamlWorkspacePackages(projectRoot);
+  if (pnpmPackages) {
+    tool = 'pnpm';
+    sources.push('pnpm-workspace.yaml');
+    packagePaths = await expandPackagePaths(projectRoot, pnpmPackages);
+  }
+
+  if (!tool) {
+    const pkg = await readPackageJson(projectRoot);
+    if (pkg && pkg.workspaces) {
+      const patterns = Array.isArray(pkg.workspaces)
+        ? pkg.workspaces
+        : Array.isArray(pkg.workspaces.packages)
+          ? pkg.workspaces.packages
+          : [];
+      if (patterns.length > 0) {
+        tool = 'npm-or-yarn';
+        sources.push('package.json');
+        packagePaths = await expandPackagePaths(projectRoot, patterns);
+      }
+    }
+  }
+
+  const markers = [
+    { file: 'lerna.json', tool: 'lerna' },
+    { file: 'nx.json', tool: 'nx' },
+    { file: 'turbo.json', tool: 'turbo' },
+    { file: 'rush.json', tool: 'rush' },
+  ];
+  for (const { file, tool: markerTool } of markers) {
+    if (await fileExists(path.join(projectRoot, file))) {
+      if (!tool) tool = markerTool;
+      sources.push(file);
+    }
+  }
+
+  if (!tool) return [];
+
+  results.push({
+    field: 'monorepo',
+    value: { isMonorepo: true, tool, packagePaths },
+    confidence: 'high',
+    source: sources.join(', '),
+    candidates: null,
+  });
+  return results;
+}

package/src/core/project-scanner/detectors/orm.js

@@ -0,0 +1,72 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { fileExists } from '../../../utils/file.js';
+import { getAllDeps } from '../manifests.js';
+
+async function findFile(projectRoot, patterns) {
+  for (const p of patterns) {
+    if (await fileExists(path.join(projectRoot, p))) return p;
+  }
+  return null;
+}
+
+async function findDrizzleConfig(projectRoot) {
+  try {
+    const entries = await fs.readdir(projectRoot, { withFileTypes: true });
+    const match = entries.find(
+      (e) => e.isFile() && /^drizzle\.config\.(js|ts|mjs|cjs)$/.test(e.name)
+    );
+    return match ? match.name : null;
+  } catch {
+    return null;
+  }
+}
+
+const SIMPLE_ORMS = [
+  { deps: ['sequelize', '@sequelize/core'], name: 'Sequelize', source: 'package.json', from: 'js' },
+  { deps: ['typeorm'], name: 'TypeORM', source: 'package.json', from: 'js' },
+  { deps: ['mongoose'], name: 'Mongoose', source: 'package.json', from: 'js' },
+  { deps: ['sqlalchemy', 'SQLAlchemy'], name: 'SQLAlchemy', source: 'pyproject.toml', from: 'py' },
+  { deps: ['tortoise-orm'], name: 'Tortoise ORM', source: 'pyproject.toml', from: 'py' },
+];
+
+function ormResult(name, schemaFile, source) {
+  return {
+    field: 'orm',
+    value: { name, schemaFile: schemaFile ?? null },
+    confidence: 'high',
+    source,
+    candidates: null,
+  };
+}
+
+export default async function detectOrm(projectRoot) {
+  const { js, py } = await getAllDeps(projectRoot);
+  const results = [];
+
+  if (js['prisma'] !== undefined || js['@prisma/client'] !== undefined) {
+    const schemaFile = await findFile(projectRoot, ['prisma/schema.prisma']);
+    results.push(ormResult('Prisma', schemaFile, schemaFile || 'package.json'));
+  }
+
+  if (js['drizzle-orm'] !== undefined) {
+    const schemaFile = await findDrizzleConfig(projectRoot);
+    results.push(ormResult('Drizzle', schemaFile, schemaFile || 'package.json'));
+  }
+
+  for (const { deps, name, source, from } of SIMPLE_ORMS) {
+    const map = from === 'js' ? js : py;
+    if (deps.some((d) => map[d] !== undefined)) {
+      results.push(ormResult(name, null, source));
+    }
+  }
+
+  const alembicIni = (await fileExists(path.join(projectRoot, 'alembic.ini')))
+    ? 'alembic.ini'
+    : null;
+  if (py['alembic'] !== undefined || alembicIni) {
+    results.push(ormResult('Alembic', alembicIni, alembicIni || 'pyproject.toml'));
+  }
+
+  return results;
+}

package/src/core/project-scanner/detectors/package-manager.js

@@ -0,0 +1,57 @@
+import path from 'node:path';
+import { fileExists } from '../../../utils/file.js';
+
+const LOCKFILES = [
+  { file: 'pnpm-lock.yaml', manager: 'pnpm', group: 'js' },
+  { file: 'yarn.lock', manager: 'yarn', group: 'js' },
+  { file: 'package-lock.json', manager: 'npm', group: 'js' },
+  { file: 'bun.lock', manager: 'bun', group: 'js' },
+  { file: 'bun.lockb', manager: 'bun', group: 'js' },
+  { file: 'poetry.lock', manager: 'poetry', group: 'python' },
+  { file: 'uv.lock', manager: 'uv', group: 'python' },
+  { file: 'Pipfile.lock', manager: 'pipenv', group: 'python' },
+  { file: 'Cargo.lock', manager: 'cargo', group: 'rust' },
+  { file: 'Gemfile.lock', manager: 'bundler', group: 'ruby' },
+  { file: 'go.sum', manager: 'go', group: 'go' },
+];
+
+export default async function detectPackageManager(projectRoot) {
+  const present = [];
+  for (const entry of LOCKFILES) {
+    if (await fileExists(path.join(projectRoot, entry.file))) {
+      present.push(entry);
+    }
+  }
+  if (present.length === 0) return [];
+
+  const byGroup = new Map();
+  for (const entry of present) {
+    if (!byGroup.has(entry.group)) byGroup.set(entry.group, []);
+    byGroup.get(entry.group).push(entry);
+  }
+
+  const results = [];
+  for (const group of byGroup.values()) {
+    if (group.length === 1) {
+      const { file, manager } = group[0];
+      results.push({
+        field: 'packageManager',
+        value: manager,
+        confidence: 'high',
+        source: file,
+        candidates: null,
+      });
+    } else {
+      const managers = group.map((g) => g.manager);
+      const sources = group.map((g) => g.file);
+      results.push({
+        field: 'packageManager',
+        value: group[0].manager,
+        confidence: 'medium',
+        source: sources.join(', '),
+        candidates: managers,
+      });
+    }
+  }
+  return results;
+}

package/src/core/project-scanner/detectors/readme.js

@@ -0,0 +1,123 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { fileExists, readFile } from '../../../utils/file.js';
+
+const README_CANDIDATES = ['README.md', 'README.rst', 'README.txt'];
+const SETUP_HEADING = /installation|getting\s*started|setup|quick\s*start/i;
+const SETUP_CAP = 2000;
+const MIN_DESCRIPTION_LENGTH = 20;
+// Cap full-file read to keep a pathological 50MB README from blocking the scan.
+const MAX_README_BYTES = 512 * 1024;
+const BADGE_PATTERNS = [/^\s*\[!\[.*?\]\(.*?\)\]\(.*?\)\s*$/, /^\s*!\[.*?\]\(.*?\)\s*$/];
+
+function stripHtmlComments(text) {
+  return text.replace(/<!--[\s\S]*?-->/g, '');
+}
+
+function stripHtmlTags(text) {
+  return text.replace(/<[^>]+>/g, '');
+}
+
+function isSkippable(line) {
+  if (line.trim() === '') return true;
+  return BADGE_PATTERNS.some((p) => p.test(line));
+}
+
+function stripLeadingBadges(lines) {
+  const result = [...lines];
+  while (result.length > 0 && isSkippable(result[0])) {
+    result.shift();
+  }
+  return result;
+}
+
+function firstNonEmptyParagraph(lines, startIndex) {
+  let i = startIndex;
+  while (i < lines.length && isSkippable(lines[i])) i++;
+  if (i >= lines.length) return null;
+  const paragraph = [];
+  while (i < lines.length && lines[i].trim() !== '') {
+    if (/^#{1,6}\s/.test(lines[i])) break;
+    if (isSkippable(lines[i])) {
+      i++;
+      continue;
+    }
+    paragraph.push(lines[i]);
+    i++;
+  }
+  const text = paragraph.join(' ').trim();
+  return text.length > 0 ? text : null;
+}
+
+function findH1Index(lines) {
+  return lines.findIndex((line) => /^#\s+/.test(line));
+}
+
+function extractSetupInstructions(lines) {
+  const startIdx = lines.findIndex(
+    (line) => /^#{1,6}\s/.test(line) && SETUP_HEADING.test(line.replace(/^#+\s+/, ''))
+  );
+  if (startIdx === -1) return null;
+  const body = [];
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (/^#{1,6}\s/.test(lines[i])) break;
+    body.push(lines[i]);
+  }
+  const text = body.join('\n').trim();
+  if (text.length === 0) return null;
+  return text.length > SETUP_CAP ? text.slice(0, SETUP_CAP) : text;
+}
+
+export default async function detectReadme(projectRoot) {
+  let sourceFile = null;
+  let content = null;
+  for (const candidate of README_CANDIDATES) {
+    const p = path.join(projectRoot, candidate);
+    if (await fileExists(p)) {
+      sourceFile = candidate;
+      const stat = await fs.stat(p);
+      if (stat.size > MAX_README_BYTES) {
+        // Oversized README — read just the head; description/setup headings are near the top.
+        const handle = await fs.open(p, 'r');
+        try {
+          const buf = Buffer.alloc(MAX_README_BYTES);
+          const { bytesRead } = await handle.read(buf, 0, MAX_README_BYTES, 0);
+          content = buf.subarray(0, bytesRead).toString('utf-8');
+        } finally {
+          await handle.close();
+        }
+      } else {
+        content = await readFile(p);
+      }
+      break;
+    }
+  }
+  if (!sourceFile) return [];
+
+  const cleaned = stripHtmlTags(stripHtmlComments(content));
+  const rawLines = cleaned.split(/\r?\n/);
+  const lines = stripLeadingBadges(rawLines);
+
+  const h1Index = findH1Index(lines);
+  const descStart = h1Index === -1 ? 0 : h1Index + 1;
+  let projectDescription = firstNonEmptyParagraph(lines, descStart);
+  if (projectDescription && projectDescription.length < MIN_DESCRIPTION_LENGTH) {
+    projectDescription = null;
+  }
+
+  const setupInstructions = extractSetupInstructions(lines);
+
+  return [
+    {
+      field: 'readme',
+      value: {
+        projectDescription,
+        setupInstructions,
+        fullPath: sourceFile,
+      },
+      confidence: 'medium',
+      source: sourceFile,
+      candidates: null,
+    },
+  ];
+}

package/src/core/project-scanner/detectors/scripts.js

@@ -0,0 +1,128 @@
+import path from 'node:path';
+import YAML from 'yaml';
+import { fileExists, readFile } from '../../../utils/file.js';
+import { readPackageJson } from '../manifests.js';
+
+const ALL_SCRIPTS_CAP = 50;
+
+function pickScript(scripts, candidates) {
+  for (const key of candidates) {
+    if (scripts[key]) return { key, value: scripts[key] };
+  }
+  return null;
+}
+
+function firstTestScript(scripts) {
+  if (scripts['test']) return { key: 'test', value: scripts['test'] };
+  if (scripts['test:unit']) return { key: 'test:unit', value: scripts['test:unit'] };
+  const key = Object.keys(scripts).find((k) => k.startsWith('test:'));
+  return key ? { key, value: scripts[key] } : null;
+}
+
+async function readMakefileTargets(projectRoot) {
+  const filePath = path.join(projectRoot, 'Makefile');
+  if (!(await fileExists(filePath))) return [];
+  try {
+    const raw = await readFile(filePath);
+    const targets = new Set();
+    for (const line of raw.split(/\r?\n/)) {
+      const match = line.match(/^([A-Za-z][A-Za-z0-9_-]*)\s*:(?!=)/);
+      if (match) targets.add(match[1]);
+    }
+    return Array.from(targets);
+  } catch {
+    return [];
+  }
+}
+
+async function readTaskfile(projectRoot) {
+  const filePath = path.join(projectRoot, 'Taskfile.yml');
+  if (!(await fileExists(filePath))) return [];
+  try {
+    const raw = await readFile(filePath);
+    const parsed = YAML.parse(raw);
+    if (parsed && parsed.tasks && typeof parsed.tasks === 'object') {
+      return Object.keys(parsed.tasks);
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+async function readJustfile(projectRoot) {
+  const filePath = path.join(projectRoot, 'justfile');
+  if (!(await fileExists(filePath))) return [];
+  try {
+    const raw = await readFile(filePath);
+    const recipes = new Set();
+    for (const line of raw.split(/\r?\n/)) {
+      const match = line.match(/^([a-zA-Z][a-zA-Z0-9_-]*)\s*(?::|\s+[a-zA-Z])/);
+      if (match) recipes.add(match[1]);
+    }
+    return Array.from(recipes);
+  } catch {
+    return [];
+  }
+}
+
+export default async function detectScripts(projectRoot) {
+  const pkg = await readPackageJson(projectRoot);
+  const scripts = pkg && pkg.scripts ? pkg.scripts : {};
+
+  const dev = pickScript(scripts, ['dev', 'start', 'serve']);
+  const test = firstTestScript(scripts);
+  const build = pickScript(scripts, ['build', 'compile']);
+  const lint = pickScript(scripts, ['lint', 'check']);
+
+  let truncated = false;
+  let allScripts = {};
+  const entries = Object.entries(scripts);
+  if (entries.length > ALL_SCRIPTS_CAP) {
+    truncated = true;
+    for (const [k, v] of entries.slice(0, ALL_SCRIPTS_CAP)) allScripts[k] = v;
+  } else {
+    allScripts = { ...scripts };
+  }
+
+  const sources = [];
+  if (pkg) sources.push('package.json');
+
+  const makefileTargets = await readMakefileTargets(projectRoot);
+  const taskfileTasks = await readTaskfile(projectRoot);
+  const justfileRecipes = await readJustfile(projectRoot);
+  if (makefileTargets.length > 0) sources.push('Makefile');
+  if (taskfileTasks.length > 0) sources.push('Taskfile.yml');
+  if (justfileRecipes.length > 0) sources.push('justfile');
+
+  if (
+    !pkg &&
+    makefileTargets.length === 0 &&
+    taskfileTasks.length === 0 &&
+    justfileRecipes.length === 0
+  ) {
+    return [];
+  }
+
+  const value = {
+    dev: dev ? { key: dev.key, command: dev.value } : null,
+    test: test ? { key: test.key, command: test.value } : null,
+    build: build ? { key: build.key, command: build.value } : null,
+    lint: lint ? { key: lint.key, command: lint.value } : null,
+    allScripts,
+    makefileTargets,
+    taskfileTasks,
+    justfileRecipes,
+  };
+  if (truncated) value.truncated = true;
+
+  return [
+    {
+      field: 'scripts',
+      value,
+      confidence: 'high',
+      source: sources.join(', '),
+      candidates: null,
+    },
+  ];
+}

package/src/core/project-scanner/detectors/spec-docs.js

@@ -0,0 +1,110 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { readFile } from '../../../utils/file.js';
+
+const EXCLUDES = new Set([
+  'node_modules',
+  '.git',
+  '.claude',
+  'dist',
+  'build',
+  '.next',
+  'target',
+  'vendor',
+  '.venv',
+  '__pycache__',
+  '.cache',
+]);
+
+const MAX_FILES = 200;
+const MAX_DEPTH = 3;
+const HEADING_CHAR_CAP = 80;
+const ROOT_PATTERNS = [/^PRD/i, /^SPEC/i, /^REQUIREMENTS/i];
+
+async function rootMatches(projectRoot) {
+  const matches = [];
+  try {
+    const entries = await fs.readdir(projectRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (ROOT_PATTERNS.some((p) => p.test(entry.name))) {
+        matches.push(entry.name);
+      }
+    }
+  } catch {
+    /* missing or unreadable — non-fatal */
+  }
+  return matches;
+}
+
+async function walkDocs(dir, projectRoot, depth, results) {
+  if (depth > MAX_DEPTH || results.length >= MAX_FILES) return;
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= MAX_FILES) return;
+    if (EXCLUDES.has(entry.name)) continue;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDocs(fullPath, projectRoot, depth + 1, results);
+    } else if (entry.isFile() && /\.(md|txt)$/i.test(entry.name)) {
+      results.push(path.relative(projectRoot, fullPath).split(path.sep).join('/'));
+    }
+  }
+}
+
+async function firstHeading(projectRoot, relativePath) {
+  try {
+    const raw = await readFile(path.join(projectRoot, relativePath));
+    for (const rawLine of raw.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (line === '') continue;
+      const match = line.match(/^#\s+(.+)$/);
+      if (match) return match[1].slice(0, HEADING_CHAR_CAP);
+      return line.slice(0, HEADING_CHAR_CAP);
+    }
+  } catch {
+    /* missing or unreadable — non-fatal */
+  }
+  return null;
+}
+
+export default async function detectSpecDocs(projectRoot) {
+  const docs = [];
+  const rootNames = await rootMatches(projectRoot);
+  for (const name of rootNames) docs.push(name);
+
+  const docsDir = path.join(projectRoot, 'docs');
+  try {
+    const stat = await fs.stat(docsDir);
+    if (stat.isDirectory()) {
+      await walkDocs(docsDir, projectRoot, 1, docs);
+    }
+  } catch {
+    /* missing or unreadable — non-fatal */
+  }
+
+  if (docs.length === 0) return [];
+
+  const unique = Array.from(new Set(docs));
+  const value = await Promise.all(
+    unique.map(async (relative) => ({
+      path: relative,
+      firstHeading: await firstHeading(projectRoot, relative),
+    }))
+  );
+
+  return [
+    {
+      field: 'specDocs',
+      value,
+      confidence: 'high',
+      source: 'project tree',
+      candidates: null,
+    },
+  ];
+}

package/src/core/project-scanner/detectors/testing.js

@@ -0,0 +1,88 @@
+import path from 'node:path';
+import { fileExists } from '../../../utils/file.js';
+import { getAllDeps, readPyprojectToml } from '../manifests.js';
+
+const CONFIG_VARIANTS = {
+  vitest: ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs', 'vitest.config.mts'],
+  jest: ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs'],
+  playwright: ['playwright.config.js', 'playwright.config.ts', 'playwright.config.mjs'],
+  cypress: ['cypress.config.js', 'cypress.config.ts', 'cypress.config.mjs'],
+  mocha: ['.mocharc.js', '.mocharc.json', '.mocharc.yml', '.mocharc.cjs'],
+};
+
+async function findConfig(projectRoot, variants) {
+  for (const name of variants) {
+    if (await fileExists(path.join(projectRoot, name))) return name;
+  }
+  return null;
+}
+
+async function hasPytestConfig(projectRoot) {
+  if (await fileExists(path.join(projectRoot, 'pytest.ini'))) return 'pytest.ini';
+  const pyproject = await readPyprojectToml(projectRoot);
+  if (pyproject && pyproject.tool && pyproject.tool.pytest) {
+    return 'pyproject.toml';
+  }
+  return null;
+}
+
+export default async function detectTesting(projectRoot) {
+  const { js, py } = await getAllDeps(projectRoot);
+  const results = [];
+
+  const jsFrameworkOrder = ['vitest', 'jest', 'mocha'];
+  for (const name of jsFrameworkOrder) {
+    if (js[name] !== undefined) {
+      const configFile = await findConfig(projectRoot, CONFIG_VARIANTS[name] || []);
+      results.push({
+        field: 'testing',
+        value: {
+          framework: name,
+          configFile,
+          browserTesting: false,
+        },
+        confidence: 'high',
+        source: configFile || 'package.json',
+        candidates: null,
+      });
+      break;
+    }
+  }
+
+  if (js['playwright'] !== undefined || js['@playwright/test'] !== undefined) {
+    const configFile = await findConfig(projectRoot, CONFIG_VARIANTS.playwright);
+    results.push({
+      field: 'testing',
+      value: { framework: 'playwright', configFile, browserTesting: true },
+      confidence: 'high',
+      source: configFile || 'package.json',
+      candidates: null,
+    });
+  }
+
+  if (js['cypress'] !== undefined) {
+    const configFile = await findConfig(projectRoot, CONFIG_VARIANTS.cypress);
+    results.push({
+      field: 'testing',
+      value: { framework: 'cypress', configFile, browserTesting: true },
+      confidence: 'high',
+      source: configFile || 'package.json',
+      candidates: null,
+    });
+  }
+
+  const pytestPresent =
+    py['pytest'] !== undefined || Object.keys(py).some((k) => k.startsWith('pytest-'));
+  if (pytestPresent) {
+    const configFile = await hasPytestConfig(projectRoot);
+    results.push({
+      field: 'testing',
+      value: { framework: 'pytest', configFile, browserTesting: false },
+      confidence: 'high',
+      source: configFile || 'pyproject.toml',
+      candidates: null,
+    });
+  }
+
+  return results;
+}