tack-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,232 @@
+# tack
+
+Architecture drift guard. Declare your spec. Tack enforces it.
+
+## Why Tack
+
+`tack` is a context and change-tracking layer for agent-driven software work.
+
+It gives agents and humans a shared project memory across sessions:
+
+- Captures architecture intent in `spec.yaml` and supporting context docs.
+- Detects architecture signals in code and tracks drift over time.
+- Generates handoff artifacts (`.md` + canonical `.json`) for the next agent/session.
+- Preserves machine history in append-only logs.
+- Supports explicit decision and note write-back for continuity.
+
+## Persistent Context in `.tack/`
+
+All state lives in `./.tack/` so work survives restarts, agent changes, and handoffs:
+
+- `context.md`, `goals.md`, `assumptions.md`, `open_questions.md` - human intent and constraints.
+- `decisions.md` - durable decision history with reasoning.
+- `_notes.ndjson` - timestamped agent notes between sessions.
+- `spec.yaml` - declared architecture contract (allowed/forbidden systems, constraints, optional `domains` map).
+- `_audit.yaml` - latest detector snapshot.
+- `_drift.yaml` - unresolved/accepted/rejected drift items.
+- `_logs.ndjson` - append-only machine event stream.
+- `handoffs/*.md` and `handoffs/*.json` - transfer artifacts for the next session.
+- `verification.md` - validation steps carried into handoffs.
+
+Agents and tools consume this state via:
+
+- The `tack-mcp` server (Model Context Protocol), which exposes context resources and write-back tools.
+- Direct file access to `.tack/`, where human-authored docs and machine-managed state live together.
+
+## Change Tracking Workflow
+
+- `tack status` updates `_audit.yaml` and computes drift against your spec.
+- `tack watch` continuously rescans and appends events to `_logs.ndjson`.
+- `tack handoff` packages context + machine state + git deltas for the next session.
+- `tack log` and `tack note` store decisions and notes that future agents can reuse.
+
+## Install
+
+```bash
+npm install
+npm run build
+```
+
+Optional global/local CLI use:
+
+```bash
+npm link
+# now `tack` is available globally on this machine
+```
+
+Or package for use in another project:
+
+```bash
+npm pack
+# then install the tarball in another project if desired
+```
+
+## Usage
+
+From any project directory:
+
+```bash
+node /absolute/path/to/tack/dist/index.js init
+node /absolute/path/to/tack/dist/index.js status
+node /absolute/path/to/tack/dist/index.js watch
+node /absolute/path/to/tack/dist/index.js handoff
+node /absolute/path/to/tack/dist/index.js mcp
+```
+
+Within the `tack` repo itself:
+
+```bash
+node dist/index.js help
+```
+
+## `tack watch` Preview
+
+![tack watch terminal preview](./tackpreview.png)
+
+## Typical Multi-Session Loop
+
+```bash
+# Session start
+tack status
+
+# During work
+tack watch
+
+# Record key intent changes
+tack log
+tack note
+
+# Session end
+tack handoff
+```
+
+## Using Tack with Agents
+
+Tack treats LLM agents as **clients of a deterministic engine**. Agents should read context from `.tack/` and write back through the documented channels instead of mutating machine-managed files directly.
+
+### MCP (Model Context Protocol)
+
+**Run the MCP server:** From a project that has `.tack/`, run:
+
+```bash
+tack mcp
+```
+
+If `tack` is on your PATH (e.g. `npm link` from the tack clone), that’s all you need. Or: `node /path/to/tack/dist/index.js mcp`. The server reads `.tack/` from the current working directory, so run it from your **project root**.
+
+**Cursor MCP:** Add an MCP server in Cursor (Settings → Tools & MCP) with command `tack`, args `["mcp"]`, and **cwd** = your project root (the directory that contains `.tack/`). If `tack` isn’t on PATH, use command `node`, args `["/path/to/tack/dist/index.js", "mcp"]`, cwd = project root. Restart Cursor after changing MCP config.
+
+The server (`tack-mcp`) exposes these key resources:
+
+- `tack://context/intent` – `context.md`, `goals.md`, `open_questions.md`, `decisions.md`
+- `tack://context/facts` – `implementation_status.md` and `spec.yaml`
+- `tack://context/machine_state` – `_audit.yaml` and `_drift.yaml`
+- `tack://context/decisions_recent` – recent decisions as markdown
+- `tack://handoff/latest` – latest handoff JSON (`.tack/handoffs/*.json`)
+
+And these tools for write-back:
+
+- `log_decision` – append a decision to `.tack/decisions.md` and log a `decision` event
+- `log_agent_note` – append an agent note to `.tack/_notes.ndjson`
+
+### Direct File Access
+
+Agents without MCP should:
+
+- **Read**:
+  - `.tack/spec.yaml` — architecture guardrails
+  - `.tack/context.md`, `.tack/goals.md`, `.tack/assumptions.md`, `.tack/open_questions.md`
+  - `.tack/implementation_status.md`
+  - `.tack/_audit.yaml`, `.tack/_drift.yaml`
+  - `.tack/verification.md` — validation/verification steps to run after changes
+  - `.tack/handoffs/*.json`, `.tack/handoffs/*.md`
+  - `.tack/_notes.ndjson` — agent working notes (NDJSON)
+- **Write back**:
+  - Append decisions to `.tack/decisions.md`: `- [YYYY-MM-DD] Decision — reason`
+  - Use the CLI to log notes: `tack note --message "..." --type discovered --actor agent:cursor`
+  - Or append NDJSON lines manually to `.tack/_notes.ndjson` if the CLI is not available
+
+Do **not** modify `.tack/_drift.yaml`, `.tack/_audit.yaml`, or `.tack/_logs.ndjson` directly; they are machine-managed.
+
+## Detectors and YAML rules
+
+Detection is **YAML-driven**. Bundled rules live in `src/detectors/rules/*.yaml` and are shipped with the CLI. At runtime we also load any `*.yaml` from `.tack/detectors/` (optional project extension).
+
+Each rule file uses this schema:
+
+- **Top-level:** `name`, `displayName`, `signalId`, `category` (`system` | `scope` | `risk`).
+- **`systems`:** list of entries, each with:
+  - `id` — system identifier (e.g. `nextjs`, `prisma`, `stripe`)
+  - `packages` — npm package names that imply this system
+  - `configFiles` — paths to look for (e.g. `next.config.js`)
+  - `directories` — optional dirs (e.g. `src/jobs`)
+  - `routePatterns` — optional regex strings to grep in project files
+
+If any of packages/configFiles/directories/routePatterns match for a system, one signal is emitted (confidence 1). Invalid YAML or bad regex is skipped without failing the scan. The only detectors still implemented in TypeScript are `multiuser`, `admin`, and `duplicates`; all other primary systems (framework, auth, db, payments, background_jobs, exports) are defined in YAML.
+
+## Commands
+
+### `init`
+
+- Runs a detector sweep
+- Prompts you to classify detected systems as allowed/forbidden/skip
+- Writes initial files under `./.tack/`
+
+### `status`
+
+- Runs a one-shot scan
+- Updates `./.tack/_audit.yaml`
+- Computes drift and prints summary
+
+### `watch`
+
+- Starts persistent file watching
+- Re-scans on file changes
+- Creates drift items for new violations/risks/undeclared systems
+- Sends OS notifications for violations and risks
+- Press `q` to quit
+
+### `handoff`
+
+- Reads context docs + current machine state
+- Reads file-level git changes
+- Writes `./.tack/handoffs/<timestamp>.md`
+- Writes `./.tack/handoffs/<timestamp>.json` (canonical)
+- Includes a **Validation / Verification** section driven by `.tack/verification.md`:
+  - Each bullet/numbered item becomes a `verification.steps` entry in JSON and a markdown bullet
+  - Intended for humans or external tools to know which commands/checks to run after applying the handoff
+  - Tack does **not** execute these commands automatically
+
+## Keyboard Controls
+
+In selection prompts (`init`, drift options):
+
+- `↑` / `↓` to move
+- `Enter` to confirm
+
+## Development
+
+```bash
+npm run typecheck
+bun test
+npm run dev
+```
+
+Optional Bun fast path for build contributors:
+
+```bash
+npm run build:bun
+```
+
+Optional Bun source-run for contributors who have Bun:
+
+```bash
+npm run dev:bun
+```
+
+## Notes
+
+- Offline-only (no network calls)
+- Writes are guarded to `./.tack/` only
+- Python virtual environments are ignored during scans (`venv`, `.venv`, `site-packages`) to avoid false positives
+

package/dist/App.d.ts

@@ -0,0 +1,5 @@
+type AppProps = {
+    command: "init" | "status" | "watch" | "handoff";
+};
+export declare function App({ command }: AppProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/App.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Init } from "./ui/Init.js";
+import { Status } from "./ui/Status.js";
+import { Watch } from "./ui/Watch.js";
+import { Handoff } from "./ui/Handoff.js";
+export function App({ command }) {
+    switch (command) {
+        case "init":
+            return _jsx(Init, {});
+        case "status":
+            return _jsx(Status, {});
+        case "watch":
+            return _jsx(Watch, {});
+        case "handoff":
+            return _jsx(Handoff, {});
+    }
+}

package/dist/detectors/admin.d.ts

@@ -0,0 +1,2 @@
+import { type DetectorResult } from "../lib/signals.js";
+export declare function detectAdmin(): DetectorResult;

package/dist/detectors/admin.js

@@ -0,0 +1,33 @@
+import { createSignal } from "../lib/signals.js";
+import { grepFiles, listProjectFiles } from "../lib/files.js";
+const ADMIN_ROUTE_PATTERNS = [
+    /\/admin\//,
+    /\/dashboard\/admin/,
+    /app\/admin\//,
+    /pages\/admin\//,
+    /src\/routes\/admin/,
+];
+const ADMIN_MIDDLEWARE_PATTERNS = [
+    /isAdmin|requireAdmin|adminOnly|checkAdmin|AdminGuard/,
+    /role\s*===?\s*["']admin["']/,
+    /roles?\s*\.includes\s*\(\s*["']admin["']\)/,
+];
+export function detectAdmin() {
+    try {
+        const signals = [];
+        const projectFiles = listProjectFiles();
+        const adminRouteFiles = projectFiles.filter((f) => ADMIN_ROUTE_PATTERNS.some((p) => p.test(f)));
+        if (adminRouteFiles.length > 0) {
+            signals.push(createSignal("scope", "admin_panel", adminRouteFiles.slice(0, 5).join(", "), 0.8, `${adminRouteFiles.length} admin route file(s)`));
+        }
+        const middlewareMatches = ADMIN_MIDDLEWARE_PATTERNS.flatMap((p) => grepFiles(projectFiles, p, 5));
+        if (middlewareMatches.length > 0 && adminRouteFiles.length === 0) {
+            const files = [...new Set(middlewareMatches.map((m) => m.file))];
+            signals.push(createSignal("scope", "admin_panel", files.join(", "), 0.6, "Admin guards/middleware found"));
+        }
+        return { name: "admin", signals };
+    }
+    catch {
+        return { name: "admin", signals: [] };
+    }
+}

package/dist/detectors/auth.d.ts

@@ -0,0 +1,2 @@
+import { type DetectorResult } from "../lib/signals.js";
+export declare function detectAuth(): DetectorResult;

package/dist/detectors/auth.js

@@ -0,0 +1,86 @@
+import { createSignal } from "../lib/signals.js";
+import { readJson, fileExists, grepFiles, listProjectFiles } from "../lib/files.js";
+const AUTH_SYSTEMS = [
+    {
+        id: "clerk",
+        packages: ["@clerk/nextjs", "@clerk/clerk-react", "@clerk/express"],
+        routePatterns: [/clerkMiddleware|ClerkProvider|useAuth|useUser/],
+        configFiles: [],
+    },
+    {
+        id: "nextauth",
+        packages: ["next-auth", "@auth/core"],
+        routePatterns: [/NextAuth|getServerSession|useSession/],
+        configFiles: ["auth.ts", "auth.config.ts", "src/auth.ts"],
+    },
+    {
+        id: "auth0",
+        packages: ["@auth0/nextjs-auth0", "@auth0/auth0-react", "auth0"],
+        routePatterns: [/Auth0Provider|useUser|withPageAuthRequired/],
+        configFiles: [],
+    },
+    {
+        id: "supabase-auth",
+        packages: ["@supabase/auth-helpers-nextjs", "@supabase/ssr"],
+        routePatterns: [/createClientComponentClient|createServerComponentClient/],
+        configFiles: [],
+    },
+    {
+        id: "lucia",
+        packages: ["lucia", "@lucia-auth/adapter-prisma", "@lucia-auth/adapter-drizzle"],
+        routePatterns: [/Lucia|validateSessionCookie/],
+        configFiles: [],
+    },
+    {
+        id: "passport",
+        packages: ["passport", "passport-local", "passport-google-oauth20"],
+        routePatterns: [/passport\.authenticate|passport\.use/],
+        configFiles: [],
+    },
+];
+export function detectAuth() {
+    try {
+        const signals = [];
+        const pkg = readJson("package.json");
+        const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+        const projectFiles = listProjectFiles();
+        for (const auth of AUTH_SYSTEMS) {
+            const foundPkgs = auth.packages.filter((p) => p in allDeps);
+            const foundConfig = auth.configFiles.find((f) => fileExists(f));
+            let routeMatch;
+            if (auth.routePatterns.length > 0) {
+                for (const pattern of auth.routePatterns) {
+                    const matches = grepFiles(projectFiles, pattern, 1);
+                    if (matches.length > 0) {
+                        routeMatch = matches[0].file;
+                        break;
+                    }
+                }
+            }
+            const sources = [];
+            let confidence = 0;
+            if (foundPkgs.length > 0) {
+                sources.push(`package.json (${foundPkgs.join(", ")})`);
+                confidence = 0.8;
+            }
+            if (foundConfig) {
+                sources.push(foundConfig);
+                confidence = Math.max(confidence, 0.9);
+            }
+            if (routeMatch) {
+                sources.push(routeMatch);
+                confidence = Math.min(confidence + 0.1, 1);
+            }
+            if (foundPkgs.length > 0 && (foundConfig || routeMatch)) {
+                confidence = 1;
+            }
+            if (sources.length > 0) {
+                signals.push(createSignal("system", "auth", sources.join(" + "), confidence, auth.id));
+            }
+        }
+        return { name: "auth", signals };
+    }
+    catch {
+        return { name: "auth", signals: [] };
+    }
+}

package/dist/detectors/database.d.ts

@@ -0,0 +1,2 @@
+import { type DetectorResult } from "../lib/signals.js";
+export declare function detectDatabase(): DetectorResult;

package/dist/detectors/database.js

@@ -0,0 +1,96 @@
+import { createSignal } from "../lib/signals.js";
+import { readJson, readFile, fileExists } from "../lib/files.js";
+const ORM_SYSTEMS = [
+    {
+        id: "prisma",
+        packages: ["prisma", "@prisma/client"],
+        configFiles: ["prisma/schema.prisma"],
+        dbTypeExtractor: (content) => {
+            const match = content.match(/provider\s*=\s*"(postgresql|mysql|sqlite|mongodb|sqlserver|cockroachdb)"/);
+            return match?.[1] ?? null;
+        },
+    },
+    {
+        id: "drizzle",
+        packages: ["drizzle-orm", "drizzle-kit"],
+        configFiles: ["drizzle.config.ts", "drizzle.config.js"],
+        dbTypeExtractor: (content) => {
+            if (content.includes("pg") || content.includes("postgres"))
+                return "postgres";
+            if (content.includes("mysql"))
+                return "mysql";
+            if (content.includes("sqlite") || content.includes("better-sqlite"))
+                return "sqlite";
+            return null;
+        },
+    },
+    {
+        id: "typeorm",
+        packages: ["typeorm"],
+        configFiles: ["ormconfig.json", "ormconfig.ts", "ormconfig.js"],
+        dbTypeExtractor: null,
+    },
+    {
+        id: "mongoose",
+        packages: ["mongoose"],
+        configFiles: [],
+        dbTypeExtractor: () => "mongodb",
+    },
+    {
+        id: "knex",
+        packages: ["knex"],
+        configFiles: ["knexfile.js", "knexfile.ts"],
+        dbTypeExtractor: null,
+    },
+];
+const DB_DRIVERS = [
+    { pkg: "pg", dbType: "postgres" },
+    { pkg: "mysql2", dbType: "mysql" },
+    { pkg: "better-sqlite3", dbType: "sqlite" },
+    { pkg: "mongodb", dbType: "mongodb" },
+    { pkg: "@libsql/client", dbType: "sqlite" },
+    { pkg: "@neondatabase/serverless", dbType: "postgres" },
+    { pkg: "@planetscale/database", dbType: "mysql" },
+];
+export function detectDatabase() {
+    try {
+        const signals = [];
+        const pkg = readJson("package.json");
+        const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+        for (const orm of ORM_SYSTEMS) {
+            const foundPkgs = orm.packages.filter((p) => p in allDeps);
+            if (foundPkgs.length === 0)
+                continue;
+            let dbType = null;
+            let configSource = null;
+            for (const cf of orm.configFiles) {
+                if (fileExists(cf)) {
+                    configSource = cf;
+                    if (orm.dbTypeExtractor) {
+                        const content = readFile(cf);
+                        if (content)
+                            dbType = orm.dbTypeExtractor(content);
+                    }
+                    break;
+                }
+            }
+            if (!dbType && orm.id !== "mongoose") {
+                for (const driver of DB_DRIVERS) {
+                    if (driver.pkg in allDeps) {
+                        dbType = driver.dbType;
+                        break;
+                    }
+                }
+            }
+            const detail = dbType ? `${orm.id} + ${dbType}` : orm.id;
+            const sources = [`package.json (${foundPkgs.join(", ")})`];
+            if (configSource)
+                sources.push(configSource);
+            signals.push(createSignal("system", "db", sources.join(" + "), configSource ? 1 : 0.8, detail));
+        }
+        return { name: "database", signals };
+    }
+    catch {
+        return { name: "database", signals: [] };
+    }
+}

package/dist/detectors/duplicates.d.ts

@@ -0,0 +1,2 @@
+import type { Signal, DetectorResult } from "../lib/signals.js";
+export declare function detectDuplicates(allSignals: Signal[]): DetectorResult;

package/dist/detectors/duplicates.js

@@ -0,0 +1,23 @@
+import { createSignal } from "../lib/signals.js";
+export function detectDuplicates(allSignals) {
+    const signals = [];
+    const systemSignals = allSignals.filter((s) => s.category === "system");
+    const grouped = new Map();
+    for (const sig of systemSignals) {
+        const existing = grouped.get(sig.id) ?? [];
+        existing.push(sig);
+        grouped.set(sig.id, existing);
+    }
+    for (const [id, sigs] of grouped) {
+        if (sigs.length <= 1)
+            continue;
+        const details = sigs
+            .map((s) => s.detail)
+            .filter((d) => Boolean(d))
+            .filter((v, i, arr) => arr.indexOf(v) === i);
+        if (details.length > 1) {
+            signals.push(createSignal("risk", `duplicate_${id}`, sigs.map((s) => s.source).join(" + "), 0.9, `Multiple ${id} systems: ${details.join(" + ")}`));
+        }
+    }
+    return { name: "duplicates", signals };
+}

package/dist/detectors/exports.d.ts

@@ -0,0 +1,2 @@
+import { type DetectorResult } from "../lib/signals.js";
+export declare function detectExports(): DetectorResult;

package/dist/detectors/exports.js

@@ -0,0 +1,30 @@
+import { createSignal } from "../lib/signals.js";
+import { readJson } from "../lib/files.js";
+const EXPORT_PACKAGES = [
+    { pkg: "jspdf", detail: "jspdf" },
+    { pkg: "pdfkit", detail: "pdfkit" },
+    { pkg: "@react-pdf/renderer", detail: "react-pdf" },
+    { pkg: "puppeteer", detail: "puppeteer" },
+    { pkg: "playwright", detail: "playwright" },
+    { pkg: "html2canvas", detail: "html2canvas" },
+    { pkg: "exceljs", detail: "exceljs" },
+    { pkg: "xlsx", detail: "sheetjs" },
+    { pkg: "csv-writer", detail: "csv-writer" },
+    { pkg: "csv-stringify", detail: "csv-stringify" },
+    { pkg: "json2csv", detail: "json2csv" },
+];
+export function detectExports() {
+    try {
+        const signals = [];
+        const pkg = readJson("package.json");
+        const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+        const found = EXPORT_PACKAGES.filter((e) => e.pkg in allDeps);
+        if (found.length > 0) {
+            signals.push(createSignal("system", "exports", `package.json (${found.map((f) => f.pkg).join(", ")})`, 0.9, found.map((f) => f.detail).join(", ")));
+        }
+        return { name: "exports", signals };
+    }
+    catch {
+        return { name: "exports", signals: [] };
+    }
+}

package/dist/detectors/framework.d.ts

@@ -0,0 +1,2 @@
+import { type DetectorResult } from "../lib/signals.js";
+export declare function detectFramework(): DetectorResult;

package/dist/detectors/framework.js

@@ -0,0 +1,71 @@
+import { createSignal } from "../lib/signals.js";
+import { readJson, fileExists } from "../lib/files.js";
+const FRAMEWORKS = [
+    {
+        id: "nextjs",
+        packages: ["next"],
+        configFiles: ["next.config.js", "next.config.mjs", "next.config.ts"],
+    },
+    {
+        id: "remix",
+        packages: ["@remix-run/node", "@remix-run/react"],
+        configFiles: ["remix.config.js"],
+    },
+    {
+        id: "sveltekit",
+        packages: ["@sveltejs/kit"],
+        configFiles: ["svelte.config.js"],
+    },
+    {
+        id: "vite",
+        packages: ["vite"],
+        configFiles: ["vite.config.ts", "vite.config.js"],
+    },
+    {
+        id: "express",
+        packages: ["express"],
+        configFiles: [],
+    },
+    {
+        id: "fastify",
+        packages: ["fastify"],
+        configFiles: [],
+    },
+    {
+        id: "hono",
+        packages: ["hono"],
+        configFiles: [],
+    },
+    {
+        id: "astro",
+        packages: ["astro"],
+        configFiles: ["astro.config.mjs", "astro.config.ts"],
+    },
+];
+export function detectFramework() {
+    try {
+        const signals = [];
+        const pkg = readJson("package.json");
+        const allDeps = {
+            ...pkg?.dependencies,
+            ...pkg?.devDependencies,
+        };
+        for (const fw of FRAMEWORKS) {
+            const foundPkg = fw.packages.find((p) => p in allDeps);
+            const foundConfig = fw.configFiles.find((f) => fileExists(f));
+            if (foundPkg && foundConfig) {
+                signals.push(createSignal("system", "framework", `package.json (${foundPkg}) + ${foundConfig}`, 1, fw.id));
+            }
+            else if (foundPkg) {
+                signals.push(createSignal("system", "framework", `package.json (${foundPkg})`, 0.9, fw.id));
+            }
+            else if (foundConfig) {
+                signals.push(createSignal("system", "framework", foundConfig, 0.8, fw.id));
+            }
+        }
+        return { name: "framework", signals };
+    }
+    catch {
+        return { name: "framework", signals: [] };
+    }
+}

package/dist/detectors/index.d.ts

@@ -0,0 +1,12 @@
+import type { Signal, DetectorResult } from "../lib/signals.js";
+export type DetectorEntry = {
+    name: string;
+    displayName: string;
+    run: () => DetectorResult;
+};
+export declare const PRIMARY_DETECTORS: DetectorEntry[];
+export declare function runAllDetectors(): {
+    results: DetectorResult[];
+    signals: Signal[];
+};
+export declare function detectorsForFileChange(filepath: string): DetectorEntry[];