worclaude 2.5.1 → 2.6.0

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

@@ -0,0 +1,131 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { fileExists } from '../../../utils/file.js';
+
+async function hasAnyJsFile(projectRoot) {
+  try {
+    const entries = await fs.readdir(projectRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && /\.(js|mjs|cjs)$/.test(entry.name)) return true;
+    }
+    const srcDir = path.join(projectRoot, 'src');
+    if (await fileExists(srcDir)) {
+      const srcEntries = await fs.readdir(srcDir, { withFileTypes: true });
+      for (const entry of srcEntries) {
+        if (entry.isFile() && /\.(js|mjs|cjs)$/.test(entry.name)) return true;
+      }
+    }
+  } catch {
+    /* missing or unreadable — non-fatal */
+  }
+  return false;
+}
+
+async function hasTsFiles(projectRoot) {
+  try {
+    const srcDir = path.join(projectRoot, 'src');
+    if (await fileExists(srcDir)) {
+      const entries = await fs.readdir(srcDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name)) return true;
+      }
+    }
+  } catch {
+    /* missing or unreadable — non-fatal */
+  }
+  return false;
+}
+
+export default async function detectLanguage(projectRoot) {
+  const results = [];
+  const has = async (f) => fileExists(path.join(projectRoot, f));
+
+  if (await has('tsconfig.json')) {
+    results.push({
+      field: 'language',
+      value: 'TypeScript',
+      confidence: 'high',
+      source: 'tsconfig.json',
+      candidates: null,
+    });
+  } else if (await has('jsconfig.json')) {
+    results.push({
+      field: 'language',
+      value: 'JavaScript',
+      confidence: 'high',
+      source: 'jsconfig.json',
+      candidates: null,
+    });
+  } else if ((await hasAnyJsFile(projectRoot)) && !(await hasTsFiles(projectRoot))) {
+    results.push({
+      field: 'language',
+      value: 'JavaScript',
+      confidence: 'high',
+      source: '*.js files',
+      candidates: null,
+    });
+  }
+
+  const pythonFiles = ['pyproject.toml', 'setup.py', 'requirements.txt'];
+  for (const f of pythonFiles) {
+    if (await has(f)) {
+      results.push({
+        field: 'language',
+        value: 'Python',
+        confidence: 'high',
+        source: f,
+        candidates: null,
+      });
+      break;
+    }
+  }
+  if (!results.some((r) => r.value === 'Python')) {
+    try {
+      const entries = await fs.readdir(projectRoot, { withFileTypes: true });
+      const reqFile = entries.find((e) => e.isFile() && /^requirements.*\.txt$/.test(e.name));
+      if (reqFile) {
+        results.push({
+          field: 'language',
+          value: 'Python',
+          confidence: 'high',
+          source: reqFile.name,
+          candidates: null,
+        });
+      }
+    } catch {
+      /* missing or unreadable — non-fatal */
+    }
+  }
+
+  if (await has('Cargo.toml')) {
+    results.push({
+      field: 'language',
+      value: 'Rust',
+      confidence: 'high',
+      source: 'Cargo.toml',
+      candidates: null,
+    });
+  }
+
+  if (await has('go.mod')) {
+    results.push({
+      field: 'language',
+      value: 'Go',
+      confidence: 'high',
+      source: 'go.mod',
+      candidates: null,
+    });
+  }
+
+  if (await has('Gemfile')) {
+    results.push({
+      field: 'language',
+      value: 'Ruby',
+      confidence: 'high',
+      source: 'Gemfile',
+      candidates: null,
+    });
+  }
+
+  return results;
+}

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

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { fileExists } from '../../../utils/file.js';
+import { readPyprojectToml } from '../manifests.js';
+
+const CONFIGS = [
+  { tool: 'ESLint', patterns: [/^\.eslintrc(\..+)?$/, /^eslint\.config\.(js|ts|mjs|cjs)$/] },
+  { tool: 'Prettier', patterns: [/^\.prettierrc(\..+)?$/, /^prettier\.config\.(js|ts|mjs|cjs)$/] },
+  { tool: 'Biome', patterns: [/^biome\.jsonc?$/] },
+  { tool: 'Stylelint', patterns: [/^\.stylelintrc(\..+)?$/] },
+  { tool: 'RuboCop', patterns: [/^\.rubocop\.ya?ml$/] },
+];
+
+async function rootFiles(projectRoot) {
+  try {
+    const entries = await fs.readdir(projectRoot, { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+export default async function detectLinting(projectRoot) {
+  const files = await rootFiles(projectRoot);
+  const tools = new Set();
+  const sources = [];
+
+  for (const { tool, patterns } of CONFIGS) {
+    const match = files.find((f) => patterns.some((p) => p.test(f)));
+    if (match) {
+      tools.add(tool);
+      sources.push(match);
+    }
+  }
+
+  if (await fileExists(path.join(projectRoot, 'ruff.toml'))) {
+    tools.add('Ruff');
+    sources.push('ruff.toml');
+  } else {
+    const pyproject = await readPyprojectToml(projectRoot);
+    if (pyproject && pyproject.tool && pyproject.tool.ruff) {
+      tools.add('Ruff');
+      sources.push('pyproject.toml');
+    }
+  }
+
+  if (tools.size === 0) return [];
+
+  return [
+    {
+      field: 'linting',
+      value: Array.from(tools),
+      confidence: 'high',
+      source: sources.join(', '),
+      candidates: null,
+    },
+  ];
+}

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,
+    },
+  ];
+}