agents-md-gen 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.10.0
+
+- Detect web frameworks in ecosystems that always reported none:
+  Django/FastAPI/Flask (Python), Rails/Sinatra (Ruby), Gin/Echo/Fiber/chi
+  (Go), Axum/Actix Web/Rocket/Tauri (Rust).
+- Django projects get `python manage.py runserver` as the dev command and
+  `python manage.py test` when pytest isn't set up; Rails apps get
+  `bin/rails server` and `bin/rails test`.
+- Python commands are prefixed with `pipenv run` for pipenv projects (like
+  `poetry run`/`uv run` already were).
+- README: the Scoop install command pointed at a private repo and 404'd;
+  it now adds the public `Peshino2012/homebrew-tap` bucket.
+
+## 0.9.1
+
+- README: the GitHub Action moved to `Peshino2012/homebrew-tap/action`,
+  a public repo. The previous `uses:` line pointed at a private repo,
+  which other repos cannot use.
+
 ## 0.9.0
 
 - Point `funding`/homepage links at the public npm page (they pointed at

package/README.md

@@ -14,7 +14,8 @@ on immediately.
 On Windows, you can also install it with [Scoop](https://scoop.sh):
 
 ```
-scoop install https://raw.githubusercontent.com/Peshino2012/PD1/claude/busy-newton-5h97oh/scoop-bucket/agents-md-gen.json
+scoop bucket add peshino2012 https://github.com/Peshino2012/homebrew-tap
+scoop install peshino2012/agents-md-gen
 ```
 
 On macOS/Linux, install it with [Homebrew](https://brew.sh):
@@ -55,10 +56,11 @@ docker run --rm -v "$PWD":/workdir ghcr.io/peshino2012/agents-md-gen
 - **Node.js / TypeScript** — package manager (npm/yarn/pnpm/bun), framework
   (React, Next.js, Vue, Svelte, Express, Fastify, NestJS), test runner
   (Jest, Vitest, Mocha, Ava, node:test)
-- **Python** — package manager (pip/poetry/uv/pipenv), pytest, ruff
-- **Rust** — Cargo, workspaces, clippy
-- **Go** — go.mod, golangci-lint
-- **Ruby** — Bundler, RSpec
+- **Python** — package manager (pip/poetry/uv/pipenv), Django/FastAPI/Flask,
+  pytest or the Django test runner, ruff
+- **Rust** — Cargo, workspaces, Axum/Actix Web/Rocket/Tauri, clippy
+- **Go** — go.mod, Gin/Echo/Fiber/chi, golangci-lint
+- **Ruby** — Bundler, Rails/Sinatra, RSpec or minitest
 - **Java/Kotlin** — Maven, Gradle (with wrapper detection)
 - **PHP** — Composer, Laravel/Symfony detection, PHPUnit
 - **.NET/C#** — NuGet, xUnit/NUnit/MSTest detection
@@ -79,13 +81,22 @@ docker run --rm -v "$PWD":/workdir ghcr.io/peshino2012/agents-md-gen
 Use it directly in CI without installing anything:
 
 ```yaml
-- uses: Peshino2012/PD1@claude/busy-newton-5h97oh
+- uses: Peshino2012/homebrew-tap/action@main
   with:
     directory: .
     also-claude-md: 'true'
 ```
 
-(pin to a tagged release instead of a branch once one exists)
+Or fail CI when `AGENTS.md` goes stale:
+
+```yaml
+- uses: Peshino2012/homebrew-tap/action@main
+  with:
+    check: 'true'
+```
+
+Inputs: `directory`, `output`, `also-claude-md`, `force`, `check`, and
+`version` (defaults to `latest`; set it to pin a release).
 
 A repo can match more than one of these (e.g. a Python backend next to a
 Node frontend) — each detected stack gets its own section.
@@ -108,7 +119,7 @@ clobber one you already wrote.
 `--check` is for CI: it fails the build if `AGENTS.md` doesn't exist or no
 longer matches what the repo would generate, so a stale file (say, a new
 test framework got added but nobody regenerated it) gets caught instead of
-silently rotting. Pair it with the GitHub Action below.
+silently rotting. Pair it with the GitHub Action above.
 
 ## Example
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-md-gen",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Generate a solid AGENTS.md / CLAUDE.md for any repo by detecting its stack, commands, and structure",
   "license": "MIT",
   "funding": {
@@ -54,6 +54,10 @@
     "scala",
     "zig",
     "julia",
+    "django",
+    "fastapi",
+    "flask",
+    "rails",
     "cli",
     "codegen",
     "developer-tools"

package/src/detect.js

@@ -94,6 +94,17 @@ function detectPython(root) {
   const nameMatch = pyproject.match(/^name\s*=\s*"([^"]+)"/m);
   const usesRuff = /\bruff\b/.test(pyproject) || exists(root, 'ruff.toml');
 
+  const depsText = [pyproject, readText(root, 'requirements.txt'), readText(root, 'Pipfile')]
+    .filter(Boolean)
+    .join('\n');
+  const hasManagePy = exists(root, 'manage.py');
+  const usesDjango = hasManagePy || hasPythonDep(depsText, 'django');
+  const frameworks = [
+    usesDjango ? 'Django' : null,
+    hasPythonDep(depsText, 'fastapi') ? 'FastAPI' : null,
+    hasPythonDep(depsText, 'flask') ? 'Flask' : null,
+  ].filter(Boolean);
+
   const installCmd = {
     poetry: 'poetry install',
     uv: 'uv sync',
@@ -101,38 +112,54 @@ function detectPython(root) {
     pip: hasPyproject ? 'pip install -e .' : 'pip install -r requirements.txt',
   }[packageManager];
 
-  const testCmd = usesPytest
-    ? (packageManager === 'poetry' ? 'poetry run pytest' : packageManager === 'uv' ? 'uv run pytest' : 'pytest')
-    : null;
+  const run = { poetry: 'poetry run ', uv: 'uv run ', pipenv: 'pipenv run ' }[packageManager] || '';
+
+  let testCmd = null;
+  if (usesPytest) testCmd = `${run}pytest`;
+  else if (hasManagePy) testCmd = `${run}python manage.py test`;
 
   return {
     ecosystem: 'Python',
     name: nameMatch ? nameMatch[1] : null,
     description: null,
     packageManager,
-    frameworks: [],
-    testFramework: usesPytest ? 'pytest' : null,
+    frameworks,
+    testFramework: usesPytest ? 'pytest' : (hasManagePy ? 'Django test runner' : null),
     commands: {
       install: installCmd,
       build: null,
       test: testCmd,
       lint: usesRuff ? 'ruff check .' : (exists(root, '.flake8') ? 'flake8' : null),
-      dev: null,
+      dev: hasManagePy ? `${run}python manage.py runserver` : null,
     },
   };
 }
 
+// Matches a PyPI requirement for exactly `name` in pyproject/requirements/
+// Pipfile text: `django>=5`, `"Django[argon2]"`, `django = "*"` -- but not
+// `django-environ` or `djangorestframework`.
+function hasPythonDep(text, name) {
+  return new RegExp(`(^|["'\\s,\\[])${name}(\\s*[<>=~!\\[;"',]|\\s*$)`, 'im').test(text);
+}
+
 function detectRust(root) {
   const cargoToml = readText(root, 'Cargo.toml');
   if (!cargoToml) return null;
   const nameMatch = cargoToml.match(/^name\s*=\s*"([^"]+)"/m);
   const isWorkspace = /^\[workspace\]/m.test(cargoToml);
+  const hasCrate = (name) => new RegExp(`^\\s*${name}\\s*=`, 'm').test(cargoToml);
+  const rustFrameworks = [
+    ['axum', 'Axum'],
+    ['actix-web', 'Actix Web'],
+    ['rocket', 'Rocket'],
+    ['tauri', 'Tauri'],
+  ].filter(([crate]) => hasCrate(crate)).map(([, label]) => label);
   return {
     ecosystem: 'Rust',
     name: nameMatch ? nameMatch[1] : null,
     description: null,
     packageManager: 'cargo',
-    frameworks: isWorkspace ? ['Cargo workspace'] : [],
+    frameworks: [...(isWorkspace ? ['Cargo workspace'] : []), ...rustFrameworks],
     testFramework: 'cargo test',
     commands: {
       install: 'cargo build',
@@ -148,12 +175,18 @@ function detectGo(root) {
   const goMod = readText(root, 'go.mod');
   if (!goMod) return null;
   const moduleMatch = goMod.match(/^module\s+(\S+)/m);
+  const goFrameworks = [
+    ['github.com/gin-gonic/gin', 'Gin'],
+    ['github.com/labstack/echo', 'Echo'],
+    ['github.com/gofiber/fiber', 'Fiber'],
+    ['github.com/go-chi/chi', 'chi'],
+  ];
   return {
     ecosystem: 'Go',
     name: moduleMatch ? moduleMatch[1] : null,
     description: null,
     packageManager: 'go modules',
-    frameworks: [],
+    frameworks: goFrameworks.filter(([mod]) => goMod.includes(mod)).map(([, label]) => label),
     testFramework: 'go test',
     commands: {
       install: 'go mod download',
@@ -210,21 +243,31 @@ function detectJava(root) {
 }
 
 function detectRuby(root) {
-  if (!exists(root, 'Gemfile')) return null;
+  const gemfile = readText(root, 'Gemfile');
+  if (gemfile === null) return null;
   const hasRspec = exists(root, '.rspec') || exists(root, 'spec');
+  const hasGem = (name) => new RegExp(`^\\s*gem\\s+["']${name}["']`, 'm').test(gemfile);
+  const isRails = hasGem('rails') || exists(root, 'bin', 'rails');
+  const rails = exists(root, 'bin', 'rails') ? 'bin/rails' : 'bundle exec rails';
+
+  let testCmd = null;
+  if (hasRspec) testCmd = 'bundle exec rspec';
+  else if (isRails) testCmd = `${rails} test`;
+  else if (exists(root, 'Rakefile')) testCmd = 'bundle exec rake test';
+
   return {
     ecosystem: 'Ruby',
     name: null,
     description: null,
     packageManager: 'bundler',
-    frameworks: [],
-    testFramework: hasRspec ? 'rspec' : null,
+    frameworks: [isRails ? 'Rails' : null, hasGem('sinatra') ? 'Sinatra' : null].filter(Boolean),
+    testFramework: hasRspec ? 'rspec' : (isRails ? 'minitest' : null),
     commands: {
       install: 'bundle install',
       build: null,
-      test: hasRspec ? 'bundle exec rspec' : (exists(root, 'Rakefile') ? 'bundle exec rake test' : null),
+      test: testCmd,
       lint: exists(root, '.rubocop.yml') ? 'bundle exec rubocop' : null,
-      dev: null,
+      dev: isRails ? `${rails} server` : null,
     },
   };
 }