fix: prevent Python/Java backend projects from being detected as web frontend (#48)

Author: oscaruiz

packages/autoskills/lib.mjs

@@ -7,6 +7,7 @@ export {
   COMBO_SKILLS_MAP,
   FRONTEND_PACKAGES,
   FRONTEND_BONUS_SKILLS,
+  BACKEND_ONLY_IDS,
   WEB_FRONTEND_EXTENSIONS,
   AGENT_FOLDER_MAP,
 } from "./skills-map.mjs";
@@ -16,6 +17,7 @@ import {
   COMBO_SKILLS_MAP,
   FRONTEND_PACKAGES,
   FRONTEND_BONUS_SKILLS,
+  BACKEND_ONLY_IDS,
   WEB_FRONTEND_EXTENSIONS,
   AGENT_FOLDER_MAP,
 } from "./skills-map.mjs";
@@ -328,14 +330,12 @@ export function getAllPackageNames(pkg) {
 /**
  * Scans a single directory for known technologies by checking packages, package patterns,
  * config files, and config file content against the SKILLS_MAP.
- * Also determines whether the directory looks like a frontend project.
+ * Also determines whether the directory has frontend packages.
  * @param {string} dir - Directory to scan.
- * @returns {{ detected: object[], isFrontendByPackages: boolean, isFrontendByFiles: boolean }}
+ * @param {{ pkg?: object|null, denoJson?: object|null }} [opts] - Pre-read manifests to avoid duplicate I/O.
+ * @returns {{ detected: object[], isFrontendByPackages: boolean }}
  */
-function detectTechnologiesInDir(
-  dir,
-  { skipFrontendFiles = false, pkg: preloadedPkg, denoJson: preloadedDeno } = {},
-) {
+function detectTechnologiesInDir(dir, { pkg: preloadedPkg, denoJson: preloadedDeno } = {}) {
   const pkg = preloadedPkg !== undefined ? preloadedPkg : readPackageJson(dir);
   const allPackages = getAllPackageNames(pkg);
   const deno = preloadedDeno !== undefined ? preloadedDeno : readDenoJson(dir);
@@ -402,10 +402,8 @@ function detectTechnologiesInDir(
   }
 
   const isFrontendByPackages = allDepsArray.some((p) => FRONTEND_PACKAGES.has(p));
-  const isFrontendByFiles =
-    isFrontendByPackages || skipFrontendFiles ? false : hasWebFrontendFiles(dir);
 
-  return { detected, isFrontendByPackages, isFrontendByFiles };
+  return { detected, isFrontendByPackages };
 }
 
 /**
@@ -419,25 +417,33 @@ export function detectTechnologies(projectDir) {
   const denoJson = readDenoJson(projectDir);
   const root = detectTechnologiesInDir(projectDir, { pkg, denoJson });
   const seenIds = new Map(root.detected.map((t) => [t.id, t]));
-  let isFrontend = root.isFrontendByPackages || root.isFrontendByFiles;
+  let isFrontend = root.isFrontendByPackages;
 
   const workspaceDirs = resolveWorkspaces(projectDir, { pkg, denoJson });
   for (const wsDir of workspaceDirs) {
-    const ws = detectTechnologiesInDir(wsDir, { skipFrontendFiles: isFrontend });
+    const ws = detectTechnologiesInDir(wsDir);
 
     for (const tech of ws.detected) {
       if (!seenIds.has(tech.id)) {
         seenIds.set(tech.id, tech);
       }
     }
 
-    if (ws.isFrontendByPackages || ws.isFrontendByFiles) {
+    if (ws.isFrontendByPackages) {
       isFrontend = true;
     }
   }
 
   const detected = [...seenIds.values()];
   const detectedIds = detected.map((t) => t.id);
+
+  // Backend-only stacks (e.g. Python, Java) often contain .html templates
+  // or static .css files that should not trigger frontend classification.
+  if (!isFrontend && !detectedIds.some((id) => BACKEND_ONLY_IDS.has(id))) {
+    isFrontend = hasWebFrontendFiles(projectDir) ||
+      workspaceDirs.some((dir) => hasWebFrontendFiles(dir));
+  }
+
   const combos = detectCombos(detectedIds);
 
   return { detected, isFrontend, combos };

packages/autoskills/skills-map.mjs

@@ -473,6 +473,23 @@ export const SKILLS_MAP = [
     },
     skills: [],
   },
+  {
+    id: "python",
+    name: "Python",
+    detect: {
+      configFiles: [
+        "requirements.txt",
+        "requirements-prod.txt",
+        "pyproject.toml",
+        "setup.py",
+        "setup.cfg",
+        "Pipfile",
+        "poetry.lock",
+        "manage.py",
+      ],
+    },
+    skills: [],
+  },
   {
     id: "deno",
     name: "Deno",
@@ -744,6 +761,8 @@ export const AGENT_FOLDER_MAP = {
   ".kiro": "kiro-cli",
 };
 
+export const BACKEND_ONLY_IDS = new Set(["python", "java", "springboot"]);
+
 export const WEB_FRONTEND_EXTENSIONS = new Set([
   ".html",
   ".htm",

packages/autoskills/tests/cli.test.mjs

@@ -437,6 +437,26 @@ describe("CLI", () => {
       ok(output.includes("Node.js"));
     });
 
+    it("does NOT detect web frontend for Python-only project with --dry-run", () => {
+      writeFile(tmp.path, "requirements.txt", "flask==3.0.0");
+      writeFile(tmp.path, "app/main.py", "from flask import Flask");
+      writeFile(tmp.path, "templates/index.html", "<html><body>Hello</body></html>");
+
+      const output = run(["--dry-run"], tmp.path);
+
+      ok(output.includes("Python"));
+      ok(!output.includes("Web frontend detected"));
+      ok(!output.includes("frontend-design"));
+    });
+
+    it("detects Python from requirements.txt with --dry-run", () => {
+      writeFile(tmp.path, "requirements.txt", "flask==3.0.0");
+
+      const output = run(["--dry-run"], tmp.path);
+
+      ok(output.includes("Python"));
+    });
+
     it("adds web fundamentals when npm frontend is detected too", () => {
       writePackageJson(tmp.path, { dependencies: { react: "^19", next: "^15" } });
 

packages/autoskills/tests/detect.test.mjs

@@ -684,6 +684,72 @@ describe("detectTechnologies (monorepo)", () => {
   });
 });
 
+// ── Python detection ─────────────────────────────────────────
+
+describe("detectTechnologies (Python)", () => {
+  const tmp = useTmpDir();
+
+  it("detects Python from requirements.txt", () => {
+    writeFile(tmp.path, "requirements.txt", "flask==3.0.0");
+    const { detected } = detectTechnologies(tmp.path);
+    ok(detected.some((t) => t.id === "python"));
+  });
+
+  it("detects Python from pyproject.toml", () => {
+    writeFile(tmp.path, "pyproject.toml", "[project]\nname = 'myapp'");
+    const { detected } = detectTechnologies(tmp.path);
+    ok(detected.some((t) => t.id === "python"));
+  });
+
+  it("detects Python from setup.py", () => {
+    writeFile(tmp.path, "setup.py", "from setuptools import setup");
+    const { detected } = detectTechnologies(tmp.path);
+    ok(detected.some((t) => t.id === "python"));
+  });
+
+  it("detects Python from Pipfile", () => {
+    writeFile(tmp.path, "Pipfile", "[packages]\nflask = '*'");
+    const { detected } = detectTechnologies(tmp.path);
+    ok(detected.some((t) => t.id === "python"));
+  });
+
+  it("detects Python from manage.py (Django)", () => {
+    writeFile(tmp.path, "manage.py", "#!/usr/bin/env python");
+    const { detected } = detectTechnologies(tmp.path);
+    ok(detected.some((t) => t.id === "python"));
+  });
+
+  it("does NOT detect web frontend for Python project with .html templates", () => {
+    writeFile(tmp.path, "requirements.txt", "flask==3.0.0");
+    writeFile(tmp.path, "templates/index.html", "<html><body>Hello</body></html>");
+    const { isFrontend } = detectTechnologies(tmp.path);
+    strictEqual(isFrontend, false);
+  });
+
+  it("does NOT detect web frontend for Django project with templates", () => {
+    writeFile(tmp.path, "manage.py", "#!/usr/bin/env python");
+    writeFile(tmp.path, "templates/base.html", "{% block content %}{% endblock %}");
+    writeFile(tmp.path, "static/style.css", "body { margin: 0 }");
+    const { isFrontend } = detectTechnologies(tmp.path);
+    strictEqual(isFrontend, false);
+  });
+
+  it("detects frontend when both Python and frontend framework are present", () => {
+    writeFile(tmp.path, "requirements.txt", "flask==3.0.0");
+    writePackageJson(tmp.path, { dependencies: { react: "^19" } });
+    const { isFrontend } = detectTechnologies(tmp.path);
+    strictEqual(isFrontend, true);
+  });
+
+  it("returns correct skills (empty) for Python detection", () => {
+    writeFile(tmp.path, "requirements.txt", "flask==3.0.0");
+    const { detected } = detectTechnologies(tmp.path);
+    const python = detected.find((t) => t.id === "python");
+    ok(python);
+    deepStrictEqual(python.skills, []);
+  });
+});
+
 // ── detectCombos ──────────────────────────────────────────────
 
 describe("detectCombos", () => {