@totoroyyb/amag 0.1.0

package/README.md

@@ -0,0 +1,141 @@
+# AMAG
+
+Agent orchestration for [Antigravity](https://antigravity.google). Curated rules, workflows, and skills that transform Antigravity's AI agent into a disciplined engineering partner.
+
+Inspired by [oh-my-opencode](https://github.com/code-yeongyu/oh-my-opencode) — rebuilt from scratch for Antigravity's native tooling.
+
+## Quick Start
+
+```bash
+npm install -g @totoroyyb/amag
+
+# Initialize in your project
+cd /path/to/your/project
+amag init
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/totoroyyb/amag.git
+cd amag && npm install && npm run build && npm link
+```
+
+That's it. Your project now has a `GEMINI.md` root prompt, always-on rules, slash-command workflows, and on-demand skills.
+
+## What You Get
+
+### Core System (`GEMINI.md`)
+
+The root prompt that orchestrates everything:
+
+- **Intent Gate** — classifies every request before acting (trivial, explicit, exploratory, open-ended)
+- **True Intent Extraction** — understands what you *actually* want, not just what you typed
+- **Auto-Ultrawork** — maximum rigor is always on: full verification, zero scope reduction
+- **Codebase Assessment** — evaluates project maturity and adapts behavior accordingly
+- **Verification Protocol** — evidence-based completion with a 6-step checklist (spec compliance → build → tests → debug scan)
+
+### Rules (Always-On)
+
+Loaded into every conversation automatically.
+
+| Rule | What it does |
+|------|-------------|
+| `code-quality` | Think-first coding, surgical changes, no AI slop |
+| `error-recovery` | 3-failure escalation, blind retry prevention, hung command detection |
+| `todo-enforcement` | Task breakdown, progress tracking, never abandon work |
+| `agentic-rules` | Session start checks, active plan detection, auto-resume guidance |
+
+### Workflows (Slash Commands)
+
+Type the command to activate.
+
+| Command | What it does |
+|---------|-------------|
+| `/plan` | Planning interview with optional external consultant + critic review |
+| `/start-work` | Execute a plan task-by-task with category-aware delegation |
+| `/resume` | Cross-session resume from `.amag/active-plan.md` |
+| `/debug` | 6-phase systematic debugging with external agent escalation |
+| `/debug-escalate` | Immediately escalate to external CLI during an active `/debug` |
+| `/explore` | Read-only multi-phase codebase exploration and architecture synthesis |
+| `/ultrawork` | Maximum effort mode — 100% certainty before acting |
+| `/init-deep` | Generate hierarchical `GEMINI.md` context files across the codebase |
+
+### Skills (On-Demand)
+
+Auto-loaded when relevant, or loaded explicitly by workflows.
+
+| Skill | What it does |
+|-------|-------------|
+| `deep-work` | Autonomous exploration — read extensively, build mental model, act decisively |
+| `git-master` | Atomic commits, conventional format, rebasing, conflict resolution |
+| `browser-testing` | Visual testing via Antigravity's `browser_subagent` |
+| `frontend-ui-ux` | Design-first UI with bold aesthetics and responsive patterns |
+| `writing` | Anti-AI-slop technical writing — plain words, human tone |
+| `architecture-advisor` | Read-only design review with simplicity bias |
+| `codebase-explorer` | Structured parallel codebase research and cross-validation |
+| `external-researcher` | External library/API research — official docs and best practices |
+| `external-cli-runner` | Unified runner for Claude, Codex, and Gemini CLIs with retry logic |
+| `plan-consultant` | Pre-plan gap analysis — surface missing requirements before generation |
+| `plan-critic` | Post-plan adversarial review — verify references and executability |
+
+## Typical Workflow
+
+```
+You:   /plan add OAuth login with Google and GitHub
+Agent: [explores codebase → asks clarifying questions → drafts plan]
+       [runs plan through consultant + critic if configured]
+       → implementation_plan.md ready for review
+
+You:   /start-work
+Agent: [executes plan task-by-task: build → type-check → test after each]
+       → all tasks complete, verified with evidence
+
+You:   /resume                      # pick up where you left off in a new session
+
+You:   /debug login redirects fail on Safari
+Agent: [reproduce → hypothesize → instrument → root-cause → fix → verify]
+       [escalates to external CLI if stuck: /debug-escalate]
+
+You:   /explore how does the auth middleware chain work?
+Agent: [structural scan → module deep-dives → synthesizes architecture doc]
+       → read-only, never modifies code
+```
+
+## External Agent Integration
+
+AMAG can delegate to external CLI agents (Claude, Codex, Gemini) for plan review and debugging consultation. Configure via:
+
+```bash
+amag config show                              # View current config
+amag config set review.consultant.cli claude   # Set plan consultant
+amag config set debug.consultant.cli codex     # Set debug consultant
+amag config set review.critic.thinking high    # Set thinking level
+amag config reset                              # Reset to defaults
+```
+
+Thinking levels: `max`, `high`, `medium`, `low`, `none`.
+
+## CLI Reference
+
+```bash
+amag init                    # Install all components
+amag update                  # Overwrite with latest templates
+amag add <type> <name>       # Install one component (rule, workflow, skill)
+amag remove <type> <name>    # Remove one component
+amag uninstall               # Remove all AMAG files
+amag list                    # Show available components
+amag doctor                  # Check installation status
+amag config show|set|reset   # Manage configuration
+```
+
+## Design Philosophy
+
+1. **System prompts are the product** — the CLI is just a delivery mechanism
+2. **Every template earns its place** — no bloat, curated for real engineering workflows
+3. **Antigravity-native** — built on AG's actual tools, not abstractions
+4. **Composable** — add only what you need, remove what you don't
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,28 @@
+export type ExternalCLI = "codex" | "claude" | "gemini-cli";
+export type ThinkingLevel = "max" | "high" | "medium" | "low" | "none";
+export interface ExternalAgentConfig {
+    cli: ExternalCLI | null;
+    model: string | null;
+    thinking: ThinkingLevel;
+}
+export interface ReviewConfig {
+    consultant: ExternalAgentConfig;
+    critic: ExternalAgentConfig;
+    timeout_ms: number;
+}
+export interface DebugConfig {
+    consultant: ExternalAgentConfig;
+    timeout_ms: number;
+}
+export interface AmagConfig {
+    review: ReviewConfig;
+    debug: DebugConfig;
+}
+export declare function getDefaultConfig(): AmagConfig;
+export declare function readConfig(targetDir: string): Promise<AmagConfig>;
+export declare function writeConfig(targetDir: string, config: AmagConfig): Promise<void>;
+/**
+ * Set a dot-path value in the config.
+ * e.g. "review.consultant.cli" → "codex"
+ */
+export declare function setConfigValue(targetDir: string, dotPath: string, value: string): Promise<void>;

package/dist/config.js

@@ -0,0 +1,78 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { resolveProjectDir, log } from "./utils.js";
+// --- Defaults ---
+const DEFAULT_CONFIG = {
+    review: {
+        consultant: { cli: "claude", model: "claude-opus-4-6", thinking: "max" },
+        critic: { cli: "codex", model: "gpt-5.2", thinking: "medium" },
+        timeout_ms: 600000,
+    },
+    debug: {
+        consultant: { cli: "codex", model: "gpt-5.2", thinking: "high" },
+        timeout_ms: 600000,
+    },
+};
+// --- Functions ---
+function configPath(projectDir) {
+    return path.join(projectDir, ".amag", "config.json");
+}
+export function getDefaultConfig() {
+    return structuredClone(DEFAULT_CONFIG);
+}
+export async function readConfig(targetDir) {
+    const projectDir = resolveProjectDir(targetDir);
+    const filePath = configPath(projectDir);
+    if (await fs.pathExists(filePath)) {
+        try {
+            const raw = await fs.readJson(filePath);
+            // Merge with defaults to handle missing keys from older configs
+            return {
+                review: {
+                    consultant: { ...DEFAULT_CONFIG.review.consultant, ...raw?.review?.consultant },
+                    critic: { ...DEFAULT_CONFIG.review.critic, ...raw?.review?.critic },
+                    timeout_ms: raw?.review?.timeout_ms ?? DEFAULT_CONFIG.review.timeout_ms,
+                },
+                debug: {
+                    consultant: { ...DEFAULT_CONFIG.debug.consultant, ...raw?.debug?.consultant },
+                    timeout_ms: raw?.debug?.timeout_ms ?? DEFAULT_CONFIG.debug.timeout_ms,
+                },
+            };
+        }
+        catch {
+            log.warn("Invalid .amag/config.json — using defaults");
+            return getDefaultConfig();
+        }
+    }
+    return getDefaultConfig();
+}
+export async function writeConfig(targetDir, config) {
+    const projectDir = resolveProjectDir(targetDir);
+    const filePath = configPath(projectDir);
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeJson(filePath, config, { spaces: 2 });
+}
+/**
+ * Set a dot-path value in the config.
+ * e.g. "review.consultant.cli" → "codex"
+ */
+export async function setConfigValue(targetDir, dotPath, value) {
+    const config = await readConfig(targetDir);
+    const parts = dotPath.split(".");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let obj = config;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (obj[parts[i]] === undefined) {
+            throw new Error(`Invalid config path: ${dotPath}`);
+        }
+        obj = obj[parts[i]];
+    }
+    const lastKey = parts[parts.length - 1];
+    if (obj[lastKey] === undefined) {
+        throw new Error(`Invalid config path: ${dotPath}`);
+    }
+    // Coerce numeric values
+    const numericValue = Number(value);
+    obj[lastKey] = Number.isNaN(numericValue) ? (value === "null" ? null : value) : numericValue;
+    await writeConfig(targetDir, config);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./installer.js";
+import { listComponents } from "./registry.js";
+import { doctorCheck } from "./utils.js";
+import readline from "node:readline/promises";
+const program = new Command();
+program
+    .name("amag")
+    .description("OmO-style agent orchestration for Antigravity — install rules, workflows, and skills")
+    .version("0.1.0");
+program
+    .command("init")
+    .description("Install all AMAG components (skips existing files with warning)")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .option("--no-gemini-md", "Skip generating GEMINI.md at project root")
+    .action(async (options) => {
+    await initCommand(options.target, { skipGeminiMd: !options.geminiMd });
+});
+program
+    .command("update")
+    .description("Overwrite all AMAG components with latest templates")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .option("--no-gemini-md", "Skip updating GEMINI.md at project root")
+    .action(async (options) => {
+    const { updateCommand } = await import("./installer.js");
+    await updateCommand(options.target, { skipGeminiMd: !options.geminiMd });
+});
+program
+    .command("add <type> <name>")
+    .description("Add a single component (rule, workflow, or skill)")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .action(async (type, name, options) => {
+    const { addComponent } = await import("./installer.js");
+    await addComponent(type, name, options.target);
+});
+program
+    .command("uninstall")
+    .description("Remove all AMAG-managed files from the target project")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .option("--keep-gemini-md", "Keep GEMINI.md at project root")
+    .option("-f, --force", "Skip confirmation prompt")
+    .action(async (options) => {
+    if (!options.force) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await rl.question("This will remove all AMAG components. Continue? (y/N) ");
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+            console.log("Cancelled.");
+            return;
+        }
+    }
+    const { uninstallCommand } = await import("./installer.js");
+    await uninstallCommand(options.target, { keepGeminiMd: !!options.keepGeminiMd });
+});
+program
+    .command("remove <type> <name>")
+    .description("Remove a single component (rule, workflow, or skill)")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .action(async (type, name, options) => {
+    const { removeComponent } = await import("./installer.js");
+    await removeComponent(type, name, options.target);
+});
+program
+    .command("list")
+    .description("List all available components")
+    .action(() => {
+    listComponents();
+});
+program
+    .command("doctor")
+    .description("Check what AMAG components are installed in the target project")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .action(async (options) => {
+    await doctorCheck(options.target);
+});
+const configCmd = program
+    .command("config")
+    .description("Manage AMAG review configuration");
+configCmd
+    .command("show")
+    .description("Show current review configuration")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .action(async (options) => {
+    const { readConfig } = await import("./config.js");
+    const config = await readConfig(options.target);
+    console.log(JSON.stringify(config, null, 2));
+});
+configCmd
+    .command("set <path> <value>")
+    .description("Set a config value (e.g. review.consultant.cli codex)")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .action(async (dotPath, value, options) => {
+    const { setConfigValue, readConfig } = await import("./config.js");
+    await setConfigValue(options.target, dotPath, value);
+    const config = await readConfig(options.target);
+    const { log } = await import("./utils.js");
+    log.success(`Set ${dotPath} = ${value}`);
+    console.log(JSON.stringify(config, null, 2));
+});
+configCmd
+    .command("reset")
+    .description("Reset configuration to defaults")
+    .option("-t, --target <dir>", "Target project directory", ".")
+    .action(async (options) => {
+    const { writeConfig, getDefaultConfig } = await import("./config.js");
+    await writeConfig(options.target, getDefaultConfig());
+    const { log } = await import("./utils.js");
+    log.success("Configuration reset to defaults");
+    console.log(JSON.stringify(getDefaultConfig(), null, 2));
+});
+program.parse();

package/dist/installer.d.ts

@@ -0,0 +1,12 @@
+export declare function initCommand(targetDir: string, options: {
+    skipGeminiMd: boolean;
+    force?: boolean;
+}, confirmFn?: () => Promise<boolean>): Promise<void>;
+export declare function updateCommand(targetDir: string, options: {
+    skipGeminiMd: boolean;
+}): Promise<void>;
+export declare function addComponent(type: string, name: string, targetDir: string): Promise<void>;
+export declare function uninstallCommand(targetDir: string, options: {
+    keepGeminiMd: boolean;
+}): Promise<void>;
+export declare function removeComponent(type: string, name: string, targetDir: string): Promise<void>;

package/dist/installer.js

@@ -0,0 +1,268 @@
+import { COMPONENTS } from "./registry.js";
+import { resolveProjectDir, copyTemplate, removeIfExists, cleanEmptyDirs, log } from "./utils.js";
+import path from "node:path";
+import fs from "fs-extra";
+const DEST_MAP = {
+    rule: ".agent/rules",
+    workflow: ".agent/workflows",
+    skill: ".agent/skills",
+};
+const SRC_MAP = {
+    rule: "rules",
+    workflow: "workflows",
+    skill: "skills",
+};
+function getTemplatesDir() {
+    // Resolve relative to this file's location (dist/ or src/)
+    return path.resolve(import.meta.dirname, "..", "templates");
+}
+function getDestPath(comp, projectDir) {
+    const destDir = path.join(projectDir, DEST_MAP[comp.type]);
+    if (comp.type === "skill") {
+        return path.join(destDir, comp.name, "SKILL.md");
+    }
+    return path.join(destDir, `${comp.name}.md`);
+}
+async function installComponent(comp, templatesDir, projectDir, options) {
+    const srcDir = path.join(templatesDir, SRC_MAP[comp.type]);
+    const destDir = path.join(projectDir, DEST_MAP[comp.type]);
+    if (comp.type === "skill") {
+        const srcSkillDir = path.join(srcDir, comp.name);
+        const destSkillDir = path.join(destDir, comp.name);
+        await fs.ensureDir(destSkillDir);
+        await copyTemplate(path.join(srcSkillDir, "SKILL.md"), path.join(destSkillDir, "SKILL.md"), comp.name, options);
+    }
+    else {
+        await fs.ensureDir(destDir);
+        await copyTemplate(path.join(srcDir, `${comp.name}.md`), path.join(destDir, `${comp.name}.md`), comp.name, options);
+    }
+}
+async function copyResources(templatesDir, projectDir, options) {
+    const srcDir = path.join(templatesDir, "resources");
+    const destDir = path.join(projectDir, ".agent", "resources");
+    let updated = 0;
+    let created = 0;
+    if (!(await fs.pathExists(srcDir)))
+        return { updated, created };
+    await fs.ensureDir(destDir);
+    for (const file of await fs.readdir(srcDir)) {
+        if (!file.endsWith(".md"))
+            continue;
+        const dest = path.join(destDir, file);
+        const existed = await fs.pathExists(dest);
+        await copyTemplate(path.join(srcDir, file), dest, `resource/${file}`, options);
+        if (existed)
+            updated++;
+        else
+            created++;
+    }
+    return { updated, created };
+}
+async function findExistingComponents(projectDir) {
+    const existing = [];
+    for (const comp of COMPONENTS) {
+        const dest = getDestPath(comp, projectDir);
+        if (await fs.pathExists(dest)) {
+            existing.push(`${comp.type}/${comp.name}`);
+        }
+    }
+    if (await fs.pathExists(path.join(projectDir, "GEMINI.md"))) {
+        existing.push("GEMINI.md");
+    }
+    if (await fs.pathExists(path.join(projectDir, ".amag", "config.json"))) {
+        existing.push(".amag/config.json");
+    }
+    return existing;
+}
+export async function initCommand(targetDir, options, confirmFn) {
+    const projectDir = resolveProjectDir(targetDir);
+    const templatesDir = getTemplatesDir();
+    log.header(`AMAG — Installing to ${projectDir}`);
+    // Check for existing files and warn
+    if (!options.force) {
+        const existing = await findExistingComponents(projectDir);
+        if (existing.length > 0) {
+            log.warn(`\n${existing.length} file(s) already exist and will be SKIPPED:`);
+            for (const name of existing) {
+                log.info(`  • ${name}`);
+            }
+            console.log();
+            log.info("Use `amag update` to overwrite existing files with latest templates.");
+            console.log();
+            if (confirmFn) {
+                const proceed = await confirmFn();
+                if (!proceed) {
+                    console.log("Cancelled.");
+                    return;
+                }
+            }
+        }
+    }
+    // Install all components
+    for (const comp of COMPONENTS) {
+        await installComponent(comp, templatesDir, projectDir, { force: options.force });
+    }
+    // Copy resource files (e.g., plan-template.md)
+    await copyResources(templatesDir, projectDir, { force: options.force });
+    // Generate GEMINI.md at project root
+    if (!options.skipGeminiMd) {
+        await copyTemplate(path.join(templatesDir, "GEMINI.md"), path.join(projectDir, "GEMINI.md"), "GEMINI.md", { force: options.force });
+    }
+    // Generate default .amag/config.json
+    const configPath = path.join(projectDir, ".amag", "config.json");
+    if (options.force || !(await fs.pathExists(configPath))) {
+        const { writeConfig, getDefaultConfig } = await import("./config.js");
+        await writeConfig(targetDir, getDefaultConfig());
+        log.success(".amag/config.json");
+    }
+    else {
+        log.warn(".amag/config.json (exists, skipped)");
+    }
+    log.success("\nDone! AMAG is installed.");
+    log.info("Run `amag doctor` to verify installation.");
+}
+export async function updateCommand(targetDir, options) {
+    const projectDir = resolveProjectDir(targetDir);
+    const templatesDir = getTemplatesDir();
+    log.header(`AMAG — Updating ${projectDir}`);
+    let updated = 0;
+    let created = 0;
+    for (const comp of COMPONENTS) {
+        const dest = getDestPath(comp, projectDir);
+        const existed = await fs.pathExists(dest);
+        await installComponent(comp, templatesDir, projectDir, { force: true });
+        if (existed)
+            updated++;
+        else
+            created++;
+    }
+    // Copy resource files
+    const resourceResult = await copyResources(templatesDir, projectDir, { force: true });
+    updated += resourceResult.updated;
+    created += resourceResult.created;
+    if (!options.skipGeminiMd) {
+        const geminiPath = path.join(projectDir, "GEMINI.md");
+        const existed = await fs.pathExists(geminiPath);
+        await copyTemplate(path.join(templatesDir, "GEMINI.md"), geminiPath, "GEMINI.md", { force: true });
+        if (existed)
+            updated++;
+        else
+            created++;
+    }
+    // Update .amag/config.json — merge with defaults to pick up new fields
+    const configFilePath = path.join(projectDir, ".amag", "config.json");
+    const { readConfig, writeConfig } = await import("./config.js");
+    if (await fs.pathExists(configFilePath)) {
+        // Re-read merges user overrides with latest defaults (picks up new fields)
+        const merged = await readConfig(targetDir);
+        await writeConfig(targetDir, merged);
+        log.success(".amag/config.json (merged with latest defaults)");
+        updated++;
+    }
+    else {
+        const { getDefaultConfig } = await import("./config.js");
+        await writeConfig(targetDir, getDefaultConfig());
+        log.success(".amag/config.json (created)");
+        created++;
+    }
+    console.log();
+    log.success(`Done! ${updated} updated, ${created} newly created.`);
+}
+export async function addComponent(type, name, targetDir) {
+    const validTypes = ["rule", "workflow", "skill"];
+    if (!validTypes.includes(type)) {
+        log.error(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`);
+        process.exit(1);
+    }
+    const comp = COMPONENTS.find((c) => c.type === type && c.name === name);
+    if (!comp) {
+        log.error(`Unknown ${type} "${name}". Run \`amag list\` to see available components.`);
+        process.exit(1);
+    }
+    const projectDir = resolveProjectDir(targetDir);
+    const templatesDir = getTemplatesDir();
+    await installComponent(comp, templatesDir, projectDir);
+    log.success(`\nAdded ${type} "${name}" to ${projectDir}`);
+}
+export async function uninstallCommand(targetDir, options) {
+    const projectDir = resolveProjectDir(targetDir);
+    log.header(`AMAG — Uninstalling from ${projectDir}`);
+    let removed = 0;
+    let absent = 0;
+    // Remove all registered components
+    for (const comp of COMPONENTS) {
+        const destDir = path.join(projectDir, DEST_MAP[comp.type]);
+        let filePath;
+        if (comp.type === "skill") {
+            filePath = path.join(destDir, comp.name); // entire skill directory
+        }
+        else {
+            filePath = path.join(destDir, `${comp.name}.md`);
+        }
+        const wasRemoved = await removeIfExists(filePath, `${comp.type}/${comp.name}`);
+        if (wasRemoved)
+            removed++;
+        else
+            absent++;
+    }
+    // Clean up empty directories
+    const seenDirs = new Set();
+    for (const comp of COMPONENTS) {
+        const destDir = path.join(projectDir, DEST_MAP[comp.type]);
+        if (!seenDirs.has(destDir)) {
+            seenDirs.add(destDir);
+            await cleanEmptyDirs(destDir, projectDir);
+        }
+    }
+    // Remove GEMINI.md
+    if (!options.keepGeminiMd) {
+        const wasRemoved = await removeIfExists(path.join(projectDir, "GEMINI.md"), "GEMINI.md");
+        if (wasRemoved)
+            removed++;
+        else
+            absent++;
+    }
+    // Remove .amag/config.json
+    const configRemoved = await removeIfExists(path.join(projectDir, ".amag", "config.json"), ".amag/config.json");
+    if (configRemoved)
+        removed++;
+    else
+        absent++;
+    // Remove resource files
+    const resourcesDir = path.join(projectDir, ".agent", "resources");
+    if (await fs.pathExists(resourcesDir)) {
+        const wasRemoved = await removeIfExists(resourcesDir, ".agent/resources");
+        if (wasRemoved)
+            removed++;
+        else
+            absent++;
+    }
+    // Clean .amag directory if empty
+    await cleanEmptyDirs(path.join(projectDir, ".amag"), projectDir);
+    console.log();
+    log.success(`Done! ${removed} removed, ${absent} already absent.`);
+}
+export async function removeComponent(type, name, targetDir) {
+    const validTypes = ["rule", "workflow", "skill"];
+    if (!validTypes.includes(type)) {
+        log.error(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`);
+        process.exit(1);
+    }
+    const comp = COMPONENTS.find((c) => c.type === type && c.name === name);
+    if (!comp) {
+        log.error(`Unknown ${type} "${name}". Run \`amag list\` to see available components.`);
+        process.exit(1);
+    }
+    const projectDir = resolveProjectDir(targetDir);
+    const componentType = type;
+    const destDir = path.join(projectDir, DEST_MAP[componentType]);
+    let filePath;
+    if (componentType === "skill") {
+        filePath = path.join(destDir, name);
+    }
+    else {
+        filePath = path.join(destDir, `${name}.md`);
+    }
+    await removeIfExists(filePath, `${type}/${name}`);
+    await cleanEmptyDirs(destDir, projectDir);
+}

package/dist/registry.d.ts

@@ -0,0 +1,8 @@
+export type ComponentType = "rule" | "workflow" | "skill";
+export interface Component {
+    type: ComponentType;
+    name: string;
+    description: string;
+}
+export declare const COMPONENTS: Component[];
+export declare function listComponents(): void;