@archpilotlabs/archpilot 0.0.6 → 0.0.8

package/README.md

@@ -1,18 +1,22 @@
 <p align="center">
-  <img src="https://archpilot.org/logo.svg" width="100" />
+  <img src="https://archpilot.org/media/branding/logo.svg" width="100" />
 </p>
 
 <h1 align="center">ArchPilot</h1>
 
 <p align="center">
-  Continuous architecture governance for engineering teams
+  Architecture guardrails for AI-native software development
 </p>
 
+ArchPilot validates your repository against architecture rules and helps engineering teams move faster with AI-assisted development-without sacrificing architectural integrity.
+
+**Your AI writes code. ArchPilot protects architecture.**
+
 <p align="center">
   Validate • Enforce • Measure architecture continuously
 </p>
 
-ArchPilot is a CLI that validates your repository against architecture rules and helps you keep your system **visible, enforceable, and measurable** as it evolves.
+ArchPilot makes architecture **visible, enforceable, and measurable** as your system evolves.
 
 ---
 
@@ -24,6 +28,10 @@ Over time, boundaries blur, dependencies leak, and architectural decisions drift
 
 ArchPilot turns architecture into something you can **actually validate, enforce, and track continuously**.
 
+AI accelerates code delivery-but architectural drift accelerates too.
+
+ArchPilot gives teams deterministic architecture guardrails in local development, CI, and governance workflows.
+
 ---
 
 ## 🚀 What it does
@@ -65,12 +73,9 @@ archpilot cloud connect
 archpilot cloud disconnect
 ```
 
-Cloud setup only asks for your API token. ArchPilot uses the canonical production API automatically:
-
-`https://api.archpilot.org`
-
-For local development, set `ARCHPILOT_CLOUD_URL=http://localhost:4000` before running Cloud commands. CLI `--server` remains available for one-off debugging and automated tests.
+Cloud setup only asks for your API token.
 
+ArchPilot uses the canonical production API automatically-no server URL setup required for normal use.
 Learn more:
 
 https://archpilot.org/docs

package/dist/archpilot-cli.js

@@ -210936,6 +210936,8 @@ var validCanonicalStackIds = /* @__PURE__ */ new Set([
   "java",
   "spring",
   "fastapi",
+  "django",
+  "flask",
   "python",
   "php",
   "go",
@@ -210958,6 +210960,8 @@ var canonicalStackLabels = {
   java: "Java",
   spring: "Spring",
   fastapi: "FastAPI",
+  django: "Django",
+  flask: "Flask",
   python: "Python",
   php: "PHP",
   go: "Go",
@@ -211805,6 +211809,326 @@ var stackAdaptersById = {
     resolveProjectKinds: () => ["backend"],
     getImportExtractionMode: () => "python-imports"
   }),
+  django: buildAdapter({
+    id: "django",
+    displayName: canonicalStackLabels.django,
+    ecosystem: "python",
+    category: "framework",
+    priority: 68,
+    manifestDetectionHints: [
+      "requirements.txt",
+      "pyproject.toml",
+      "Pipfile",
+      "Pipfile.lock",
+      "poetry.lock",
+      "manage.py",
+      "settings.py",
+      "urls.py",
+      "wsgi.py",
+      "asgi.py"
+    ],
+    buildToolHints: ["pip", "poetry", "django-admin"],
+    defaults: {
+      sourceRoots: [".", "src", "app"],
+      moduleRootCandidates: [".", "src", "app"],
+      apiRoots: [".", "src", "app"],
+      databaseRoots: ["migrations", "db", "database"],
+      configFiles: ["requirements.txt", "pyproject.toml", "Pipfile", "Pipfile.lock", "poetry.lock", "manage.py"],
+      fileExtensions: [".py", ".toml", ".txt", ".sql", ".yaml", ".yml"],
+      dependencyFileExtensions: [".py"],
+      ignoreDirectories: [
+        "__pycache__",
+        ".pytest_cache",
+        ".venv",
+        "venv",
+        "dist",
+        "build",
+        ".idea",
+        ...commonIgnoreDirectories
+      ],
+      entrypointHints: ["manage.py", "wsgi.py", "asgi.py", "settings.py", "urls.py"],
+      publicEntrypointDirectories: [],
+      moduleIndexFileName: "__init__.py"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let weakSignals = 0;
+      let score = 0;
+      const hasRequirementsDjango = context.hasFileMatchingPattern(
+        "requirements.txt",
+        /(^|\s)django([=<>~!]|$)/imu
+      );
+      const hasPyprojectDjango = context.hasFileMatchingPattern("pyproject.toml", /\bdjango\b/iu);
+      const hasPoetryLockDjango = context.hasFileMatchingPattern(
+        "poetry.lock",
+        /\bname\s*=\s*["']django["']/iu
+      );
+      const hasPipfileDjango = context.hasFileMatchingPattern("Pipfile", /\bdjango\b/iu);
+      const hasPipfileLockDjango = context.hasFileMatchingPattern("Pipfile.lock", /"django"\s*:/iu);
+      const hasDjangoDependencyEvidence = hasRequirementsDjango || hasPyprojectDjango || hasPoetryLockDjango || hasPipfileDjango || hasPipfileLockDjango;
+      const hasManagePy = context.hasFile("manage.py");
+      const hasDjangoSettingsModule = context.hasFileMatchingPattern(
+        "manage.py",
+        /\bDJANGO_SETTINGS_MODULE\b/u
+      );
+      const hasSettingsPy = context.hasFile("settings.py");
+      const hasUrlsPy = context.hasFile("urls.py");
+      const hasWsgiOrAsgi = context.hasFile("wsgi.py") || context.hasFile("asgi.py");
+      const hasInstalledApps = context.hasFileMatchingPattern("settings.py", /\bINSTALLED_APPS\s*=/u);
+      const hasDjangoAdmin = context.hasAnyFileMatchingPattern(/(^|\/)(manage|settings|urls|wsgi|asgi)\.py$/iu, /\bdjango-admin\b/iu);
+      const hasDjangoImport = context.hasAnyFileMatchingPattern(/\.py$/iu, /\b(from|import)\s+django\b/u);
+      const hasDjangoUrlsImport = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\bfrom\s+django\.urls\s+import\s+(?:path|include|re_path)\b/u
+      );
+      if (hasRequirementsDjango) {
+        strongSignals += 1;
+        score += 52;
+        evidence.push("Found requirements.txt with django dependency");
+      }
+      if (hasPyprojectDjango) {
+        strongSignals += 1;
+        score += 52;
+        evidence.push("Found pyproject.toml with django dependency");
+      }
+      if (hasPoetryLockDjango || hasPipfileDjango || hasPipfileLockDjango) {
+        strongSignals += 1;
+        score += 50;
+        evidence.push("Found Pipfile/lock metadata with django dependency");
+      }
+      if (hasManagePy) {
+        strongSignals += 1;
+        score += 34;
+        evidence.push("Found manage.py");
+      }
+      if (hasDjangoSettingsModule) {
+        strongSignals += 1;
+        score += 24;
+        evidence.push("Found DJANGO_SETTINGS_MODULE in manage.py");
+      }
+      if (hasInstalledApps) {
+        strongSignals += 1;
+        score += 24;
+        evidence.push("Found INSTALLED_APPS in settings.py");
+      }
+      if (hasDjangoImport) {
+        strongSignals += 1;
+        score += 22;
+        evidence.push("Found django import in source");
+      }
+      if (hasSettingsPy) {
+        mediumSignals += 1;
+        score += 12;
+        evidence.push("Found settings.py");
+      }
+      if (hasUrlsPy) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found urls.py");
+      }
+      if (hasWsgiOrAsgi) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found wsgi.py or asgi.py");
+      }
+      if (hasDjangoUrlsImport) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found Django URL routing import");
+      }
+      if (hasDjangoAdmin) {
+        weakSignals += 1;
+        score += 3;
+        evidence.push("Found django-admin reference");
+      }
+      if (context.hasDirectory("migrations")) {
+        weakSignals += 1;
+        score += 2;
+        evidence.push("Found migrations directory");
+      }
+      const hasSafeDjangoCoreEvidence = hasDjangoDependencyEvidence || hasManagePy && (hasDjangoSettingsModule || hasSettingsPy || hasUrlsPy || hasWsgiOrAsgi) || hasInstalledApps && (hasSettingsPy || hasDjangoImport) || hasDjangoImport && (hasDjangoUrlsImport || hasUrlsPy);
+      if (!hasSafeDjangoCoreEvidence || strongSignals === 0) {
+        return null;
+      }
+      const hasRestEvidence = hasUrlsPy || hasDjangoUrlsImport;
+      const confidence = strongSignals >= 2 ? "high" : strongSignals >= 1 || mediumSignals >= 3 || mediumSignals >= 2 && weakSignals >= 1 ? "medium" : "low";
+      return toResult({
+        adapterId: "django",
+        confidence,
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: hasRestEvidence ? "rest" : "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "python-imports"
+  }),
+  flask: buildAdapter({
+    id: "flask",
+    displayName: canonicalStackLabels.flask,
+    ecosystem: "python",
+    category: "framework",
+    priority: 66,
+    manifestDetectionHints: [
+      "requirements.txt",
+      "pyproject.toml",
+      "Pipfile",
+      "Pipfile.lock",
+      "poetry.lock",
+      "app.py",
+      "wsgi.py",
+      "main.py"
+    ],
+    buildToolHints: ["pip", "poetry", "flask"],
+    defaults: {
+      sourceRoots: ["app", "src", "."],
+      moduleRootCandidates: ["app", "src/app", "src", "blueprints", "api"],
+      apiRoots: ["app", "src", "blueprints", "api"],
+      databaseRoots: ["migrations", "app/db", "app/database", "src/db", "src/database"],
+      configFiles: ["requirements.txt", "pyproject.toml", "Pipfile", "Pipfile.lock", "poetry.lock"],
+      fileExtensions: [".py", ".toml", ".txt", ".sql", ".yaml", ".yml"],
+      dependencyFileExtensions: [".py"],
+      ignoreDirectories: [
+        "__pycache__",
+        ".pytest_cache",
+        ".venv",
+        "venv",
+        "dist",
+        "build",
+        ".idea",
+        ...commonIgnoreDirectories
+      ],
+      entrypointHints: ["app.py", "main.py", "wsgi.py", "app/__init__.py"],
+      publicEntrypointDirectories: [],
+      moduleIndexFileName: "__init__.py"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let weakSignals = 0;
+      let score = 0;
+      const hasRequirementsFlask = context.hasFileMatchingPattern(
+        "requirements.txt",
+        /(^|\s)flask([=<>~!]|$)/imu
+      );
+      const hasPyprojectFlask = context.hasFileMatchingPattern("pyproject.toml", /\bflask\b/iu);
+      const hasPoetryLockFlask = context.hasFileMatchingPattern(
+        "poetry.lock",
+        /\bname\s*=\s*["']flask["']/iu
+      );
+      const hasPipfileFlask = context.hasFileMatchingPattern("Pipfile", /\bflask\b/iu);
+      const hasPipfileLockFlask = context.hasFileMatchingPattern("Pipfile.lock", /"flask"\s*:/iu);
+      const hasFlaskDependencyEvidence = hasRequirementsFlask || hasPyprojectFlask || hasPoetryLockFlask || hasPipfileFlask || hasPipfileLockFlask;
+      const hasFlaskImport = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\bfrom\s+flask\s+import\s+.*\bFlask\b/u
+      );
+      const hasFlaskConstruction = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\b\w+\s*=\s*Flask\s*\(\s*__name__/u
+      );
+      const hasRouteDecorator = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /@\w+\.route\s*\(/u
+      );
+      const hasMethodRouteDecorator = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /@\w+\.(?:get|post|put|delete)\s*\(/u
+      );
+      const hasBlueprintImport = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\bfrom\s+flask\s+import\s+.*\bBlueprint\b/u
+      );
+      const hasBlueprintConstruction = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\b\w+\s*=\s*Blueprint\s*\(/u
+      );
+      const hasFlaskEntrypointConstruction = context.hasAnyFileMatchingPattern(
+        /(^|\/)(app|main|wsgi)\.py$/iu,
+        /\b\w+\s*=\s*Flask\s*\(/u
+      );
+      if (hasRequirementsFlask) {
+        strongSignals += 1;
+        score += 52;
+        evidence.push("Found requirements.txt with flask dependency");
+      }
+      if (hasPyprojectFlask) {
+        strongSignals += 1;
+        score += 52;
+        evidence.push("Found pyproject.toml with flask dependency");
+      }
+      if (hasPoetryLockFlask || hasPipfileFlask || hasPipfileLockFlask) {
+        strongSignals += 1;
+        score += 50;
+        evidence.push("Found Pipfile/lock metadata with flask dependency");
+      }
+      if (hasFlaskImport) {
+        strongSignals += 1;
+        score += 34;
+        evidence.push("Found Flask import in source");
+      }
+      if (hasFlaskConstruction) {
+        strongSignals += 1;
+        score += 34;
+        evidence.push("Found Flask application construction in source");
+      }
+      if (hasRouteDecorator) {
+        strongSignals += 1;
+        score += 22;
+        evidence.push("Found Flask route decorator in source");
+      }
+      if (hasMethodRouteDecorator) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found Flask method route decorator in source");
+      }
+      if (hasBlueprintImport) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found Blueprint import in source");
+      }
+      if (hasBlueprintConstruction) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Blueprint construction in source");
+      }
+      if (hasFlaskEntrypointConstruction) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Flask construction in app.py/main.py/wsgi.py");
+      }
+      if (context.hasDirectory("blueprints")) {
+        weakSignals += 1;
+        score += 2;
+        evidence.push("Found blueprints directory");
+      }
+      if (context.hasDirectory("app") || context.hasDirectory("src")) {
+        weakSignals += 1;
+        score += 2;
+        evidence.push("Found typical Python backend layout directory");
+      }
+      const hasSafeFlaskCoreEvidence = hasFlaskDependencyEvidence || hasFlaskImport && hasFlaskConstruction || hasFlaskImport && (hasRouteDecorator || hasMethodRouteDecorator || hasBlueprintImport) || hasBlueprintImport && hasBlueprintConstruction;
+      if (!hasSafeFlaskCoreEvidence || strongSignals === 0) {
+        return null;
+      }
+      const hasRestEvidence = hasRouteDecorator || hasMethodRouteDecorator || hasBlueprintImport;
+      const confidence = strongSignals >= 2 ? "high" : strongSignals >= 1 || mediumSignals >= 3 || mediumSignals >= 2 && weakSignals >= 1 ? "medium" : "low";
+      return toResult({
+        adapterId: "flask",
+        confidence,
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: hasRestEvidence ? "rest" : "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "python-imports"
+  }),
   python: buildAdapter({
     id: "python",
     displayName: canonicalStackLabels.python,
@@ -231312,6 +231636,8 @@ var ignoredDirectoryNames2 = /* @__PURE__ */ new Set([
 var backendStackIds = /* @__PURE__ */ new Set([
   "spring",
   "fastapi",
+  "django",
+  "flask",
   "dotnet",
   "nestjs",
   "java",
@@ -231539,6 +231865,8 @@ function toDetectedStack(adapterId) {
     case "java":
     case "spring":
     case "fastapi":
+    case "django":
+    case "flask":
     case "dotnet":
     case "python":
     case "php":
@@ -231572,6 +231900,12 @@ function resolveLanguages(stacks) {
   if (stacks.includes("fastapi")) {
     languages.add("python");
   }
+  if (stacks.includes("django")) {
+    languages.add("python");
+  }
+  if (stacks.includes("flask")) {
+    languages.add("python");
+  }
   if (stacks.includes("php")) {
     languages.add("php");
   }
@@ -233402,6 +233736,10 @@ function resolveImplementationProfile(input2) {
       return input2.apiStyleHint === "rest" ? "backend-spring-rest" : "backend-spring";
     case "fastapi":
       return input2.apiStyleHint === "rest" ? "backend-fastapi-rest" : "backend-fastapi";
+    case "django":
+      return input2.apiStyleHint === "rest" ? "backend-django-rest" : "backend-django";
+    case "flask":
+      return input2.apiStyleHint === "rest" ? "backend-flask-rest" : "backend-flask";
     case "dotnet":
       return input2.apiStyleHint === "rest" ? "backend-dotnet-webapi" : "backend-dotnet";
     case "java":
@@ -233457,6 +233795,9 @@ function resolveNormalizedProjectKinds(detection, evidence) {
     addEvidence6(evidence, `Normalized project kinds from selected adapter '${selectedAdapter.id}' hints`);
   } else if (detection.topology.topology === "monorepo" && selectedHints.length > 0) {
     normalizedKinds = uniqueSortedKinds([...heuristicKinds, ...selectedHints]);
+    if (normalizedKinds.includes("library") && !selectedHints.includes("library") && (detection.architectureStyleSignals?.sharedPackageCount ?? 0) === 0) {
+      normalizedKinds = normalizedKinds.filter((kind) => kind !== "library");
+    }
     addEvidence6(evidence, "Normalized monorepo project kinds from adapter hints plus heuristic evidence");
   } else if (heuristicKinds.length > 0) {
     normalizedKinds = uniqueSortedKinds(heuristicKinds);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archpilotlabs/archpilot",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Executable architecture governance CLI",
   "homepage": "https://archpilot.org",
   "bugs": {