@creativeintelligence/abbie 0.1.0

package/dist/cli/commands/doctor.js

@@ -0,0 +1,220 @@
+import { Flags } from "@oclif/core";
+import { runDoctor, } from "../../lib/doctor/index.js";
+import { BaseCommand } from "../base-command.js";
+export default class DoctorCommand extends BaseCommand {
+    static summary = "Validate abbie CLI environment";
+    static description = `Check that the abbie CLI environment is properly configured.
+
+Validates:
+- ~/.abbie directories exist
+- Runtime detection (node/bun)
+- Required agent binaries (claude, codex, copilot, gemini)
+- Optional tools (slack, messages, linear)
+- Environment variables for integrations
+- Unified tooling symlinks (commands → claude/codex, skills → claude/codex/copilot/gemini)
+
+With --templates:
+- ~/.abbie/templates/ exists
+- Required templates present and valid
+- JSON Schema validation
+
+With --repos:
+- Per-repo .abbie/config.json or .loop.json
+- Config validity and extends resolution
+- AGENTS.md / CLAUDE.md presence
+
+With --all:
+- All checks above`;
+    static examples = [
+        "$ abbie doctor",
+        "$ abbie doctor --fix",
+        "$ abbie doctor --templates",
+        "$ abbie doctor --repos",
+        "$ abbie doctor --all",
+        "$ abbie doctor --all --json --quiet",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        fix: Flags.boolean({
+            description: "Create missing directories automatically",
+            default: false,
+        }),
+        templates: Flags.boolean({
+            description: "Include template system validation",
+            default: false,
+        }),
+        repos: Flags.boolean({
+            description: "Include per-repo contract validation",
+            default: false,
+        }),
+        all: Flags.boolean({
+            description: "Run all checks (environment + templates + repos)",
+            default: false,
+        }),
+        "repos-path": Flags.string({
+            description: "Custom path to scan for repos",
+            default: undefined,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(DoctorCommand);
+        this.parsedFlags = flags;
+        const includeTemplates = flags.all || flags.templates;
+        const includeRepos = flags.all || flags.repos;
+        const result = await runDoctor({
+            fix: flags.fix,
+            includeTemplates,
+            includeRepos,
+            reposPath: flags["repos-path"],
+        });
+        if (!this.jsonEnabled?.()) {
+            this.renderText(result, flags.fix, includeTemplates, includeRepos);
+            // Exit non-zero if not ok (only in text mode)
+            if (!result.ok) {
+                this.exit(1);
+            }
+        }
+        // In JSON mode, return result with exitCode embedded
+        return {
+            ...result,
+            exitCode: result.ok ? 0 : 1,
+        };
+    }
+    renderText(result, _didFix, includeTemplates, includeRepos) {
+        this.log("");
+        this.log("abbie doctor");
+        this.log("─".repeat(50));
+        this.log("");
+        // Group checks by category
+        const dirChecks = result.checks.filter((c) => c.name === "agents-root" || c.name.startsWith("dir-"));
+        const runtimeCheck = result.checks.find((c) => c.name === "runtime");
+        const binChecks = result.checks.filter((c) => c.name.startsWith("bin-"));
+        const envChecks = result.checks.filter((c) => c.name.startsWith("env-"));
+        const symlinkChecks = result.checks.filter((c) => c.name.startsWith("symlink-"));
+        // Directories
+        this.log("Directories:");
+        for (const check of dirChecks) {
+            this.log(`  ${this.statusIcon(check.status)} ${check.detail}`);
+        }
+        this.log("");
+        // Runtime
+        if (runtimeCheck) {
+            this.log("Runtime:");
+            this.log(`  ${this.statusIcon(runtimeCheck.status)} ${runtimeCheck.detail}`);
+            this.log("");
+        }
+        // Binaries
+        this.log("Agent Binaries:");
+        for (const check of binChecks) {
+            const name = check.name.replace("bin-", "");
+            this.log(`  ${this.statusIcon(check.status)} ${name}: ${check.detail}`);
+        }
+        this.log("");
+        // Environment
+        this.log("Environment:");
+        for (const check of envChecks) {
+            this.log(`  ${this.statusIcon(check.status)} ${check.detail}`);
+        }
+        this.log("");
+        // Symlinks
+        if (symlinkChecks.length > 0) {
+            this.log("Unified Tooling Symlinks:");
+            for (const check of symlinkChecks) {
+                this.log(`  ${this.statusIcon(check.status)} ${check.detail}`);
+            }
+            this.log("");
+        }
+        // Templates (v2)
+        if (includeTemplates && result.templateChecks) {
+            this.log("Templates:");
+            for (const check of result.templateChecks) {
+                this.log(`  ${this.statusIcon(check.status)} ${check.detail}`);
+            }
+            this.log("");
+        }
+        // Repos (v2)
+        if (includeRepos && result.repoResults) {
+            this.log("Repos:");
+            this.renderRepoResults(result.repoResults);
+            this.log("");
+        }
+        // Summary
+        this.log("─".repeat(50));
+        if (result.summary) {
+            this.log("Summary:");
+            this.log(`  Environment: ${result.summary.environment.ok} ok, ${result.summary.environment.warn} warn, ${result.summary.environment.missing} missing`);
+            if (result.summary.templates) {
+                this.log(`  Templates: ${result.summary.templates.ok} ok, ${result.summary.templates.warn} warn, ${result.summary.templates.missing} missing`);
+            }
+            if (result.summary.repos) {
+                const r = result.summary.repos;
+                this.log(`  Repos: ${r.repos.withAgentsConfig} with .abbie/config.json, ${r.repos.withLoopJson} with .loop.json, ${r.repos.noConfig} no config`);
+            }
+            this.log("");
+        }
+        if (result.ok) {
+            this.log("✓ Environment ready");
+        }
+        else {
+            this.log("✗ Issues found");
+            this.log("");
+            // Show fixes
+            if (result.fixes.length > 0) {
+                this.log("Fixes:");
+                for (const fix of result.fixes) {
+                    this.log(`  • ${fix.hint}`);
+                }
+            }
+        }
+        this.log("");
+    }
+    renderRepoResults(results) {
+        // Group by status
+        const ok = [];
+        const warn = [];
+        const missing = [];
+        for (const result of results) {
+            const hasMissing = result.checks.some((c) => c.status === "missing");
+            const hasWarn = result.checks.some((c) => c.status === "warn");
+            if (hasMissing) {
+                missing.push(result.repo);
+            }
+            else if (hasWarn) {
+                warn.push(result.repo);
+            }
+            else {
+                ok.push(result.repo);
+            }
+        }
+        // Show counts
+        this.log(`  ${this.statusIcon("ok")} ${ok.length} repos fully configured`);
+        if (warn.length > 0) {
+            this.log(`  ${this.statusIcon("warn")} ${warn.length} repos with warnings: ${warn.join(", ")}`);
+        }
+        if (missing.length > 0) {
+            this.log(`  ${this.statusIcon("missing")} ${missing.length} repos with issues: ${missing.join(", ")}`);
+        }
+        // Show detailed issues for repos with problems
+        const problemRepos = results.filter((r) => r.checks.some((c) => c.status === "missing"));
+        if (problemRepos.length > 0 && problemRepos.length <= 5) {
+            this.log("");
+            this.log("  Issues:");
+            for (const repo of problemRepos) {
+                const issues = repo.checks.filter((c) => c.status === "missing");
+                for (const issue of issues) {
+                    this.log(`    ${repo.repo}: ${issue.detail}`);
+                }
+            }
+        }
+    }
+    statusIcon(status) {
+        switch (status) {
+            case "ok":
+                return "✓";
+            case "missing":
+                return "✗";
+            case "warn":
+                return "⚠";
+        }
+    }
+}

package/dist/cli/commands/find/index.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from "../../base-command.js";
+export default class Find extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static args: {
+        query: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+    private getTypeIcon;
+    private calculateScore;
+    private searchCLIs;
+    private searchSkills;
+    private searchPrompts;
+    private searchRoles;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/find/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/find/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAUpD,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,WAAW;IAC3C,OAAgB,WAAW,SAC4D;IACvF,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,IAAI;;MAKlB;IAEF,OAAgB,KAAK;;;;;;;MAanB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IA8D3C,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,cAAc;YAsBR,UAAU;YAsDV,YAAY;YAiDZ,aAAa;YA8Bb,WAAW;CA+B1B"}

package/dist/cli/commands/find/index.js

@@ -0,0 +1,266 @@
+import { execSync } from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+export default class Find extends BaseCommand {
+    static description = "Find tools by intent or keyword. Searches across CLIs, skills, prompts, and roles.";
+    static hidden = false;
+    static examples = [
+        '<%= config.bin %> find "run tests"',
+        '<%= config.bin %> find "send slack message"',
+        '<%= config.bin %> find "analyze code" --type cli',
+        '<%= config.bin %> find "architect" --type role',
+    ];
+    static args = {
+        query: Args.string({
+            description: "Search query (intent or keyword)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        type: Flags.string({
+            char: "t",
+            description: "Filter by tool type",
+            options: ["cli", "skill", "prompt", "role", "all"],
+            default: "all",
+        }),
+        limit: Flags.integer({
+            char: "l",
+            description: "Limit results",
+            default: 5,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(Find);
+        this.parsedFlags = flags;
+        const query = args.query.toLowerCase();
+        const toolType = flags.type;
+        const limit = flags.limit;
+        const allMatches = [];
+        // Search CLIs
+        if (toolType === "all" || toolType === "cli") {
+            const cliMatches = await this.searchCLIs(query);
+            allMatches.push(...cliMatches);
+        }
+        // Search skills
+        if (toolType === "all" || toolType === "skill") {
+            const skillMatches = await this.searchSkills(query);
+            allMatches.push(...skillMatches);
+        }
+        // Search prompts
+        if (toolType === "all" || toolType === "prompt") {
+            const promptMatches = await this.searchPrompts(query);
+            allMatches.push(...promptMatches);
+        }
+        // Search roles
+        if (toolType === "all" || toolType === "role") {
+            const roleMatches = await this.searchRoles(query);
+            allMatches.push(...roleMatches);
+        }
+        // Sort by score and limit
+        const sortedMatches = allMatches.sort((a, b) => b.score - a.score).slice(0, limit);
+        if (flags.json || flags.format === "json") {
+            return sortedMatches;
+        }
+        // Text output
+        if (sortedMatches.length === 0) {
+            console.log(`No matches found for "${args.query}"`);
+            return sortedMatches;
+        }
+        console.log(`\nFound ${sortedMatches.length} match(es) for "${args.query}":\n`);
+        for (const match of sortedMatches) {
+            const typeIcon = this.getTypeIcon(match.type);
+            console.log(`${typeIcon} ${match.name} (${match.type})`);
+            console.log(`   ${match.description}`);
+            if (match.usage) {
+                console.log(`   Usage: ${match.usage}`);
+            }
+            console.log("");
+        }
+        return sortedMatches;
+    }
+    getTypeIcon(type) {
+        switch (type) {
+            case "cli":
+                return "🔧";
+            case "skill":
+                return "⚡";
+            case "prompt":
+                return "📝";
+            case "role":
+                return "🎭";
+            default:
+                return "•";
+        }
+    }
+    calculateScore(text, query) {
+        const lowerText = text.toLowerCase();
+        const words = query.split(/\s+/);
+        // Exact match
+        if (lowerText.includes(query)) {
+            return 100;
+        }
+        // All words present
+        const allWordsPresent = words.every((word) => lowerText.includes(word));
+        if (allWordsPresent) {
+            return 80;
+        }
+        // Count matching words
+        const matchingWords = words.filter((word) => lowerText.includes(word));
+        const wordScore = (matchingWords.length / words.length) * 60;
+        return wordScore;
+    }
+    async searchCLIs(query) {
+        const clis = [
+            { name: "outline", desc: "AST-based code structure analysis", usage: "outline src/" },
+            { name: "layer", desc: "Dependency and architecture analysis", usage: "layer ." },
+            { name: "verify", desc: "Test runner adapter", usage: "verify --format=summary" },
+            {
+                name: "abbie",
+                desc: "Agent session management and orchestration",
+                usage: "abbie session start",
+            },
+            {
+                name: "abbie report",
+                desc: "Lifecycle event persistence and notifications",
+                usage: "abbie report start \"task\"",
+            },
+            { name: "abbie history", desc: "Query lifecycle event history", usage: "abbie history" },
+            { name: "mem", desc: "Memory audit and zombie cleanup", usage: "mem audit" },
+            {
+                name: "slack",
+                desc: "Slack messaging and notifications",
+                usage: "slack dm send --user luke",
+            },
+            { name: "linear", desc: "Linear issue tracking", usage: "linear issue view ARBOR-123" },
+            {
+                name: "format",
+                desc: "Cross-platform markdown formatting",
+                usage: 'echo "**bold**" | format slack',
+            },
+            {
+                name: "prompts",
+                desc: "Prompt templates and commands",
+                usage: "prompts commands export /tdd",
+            },
+            { name: "roles", desc: "Agent persona management", usage: "roles export jony" },
+            { name: "epub", desc: "E-book generation and library management", usage: "epub compile" },
+        ];
+        const matches = [];
+        for (const cli of clis) {
+            const searchText = `${cli.name} ${cli.desc}`;
+            const score = this.calculateScore(searchText, query);
+            if (score > 20) {
+                matches.push({
+                    type: "cli",
+                    name: cli.name,
+                    description: cli.desc,
+                    score,
+                    usage: cli.usage,
+                });
+            }
+        }
+        return matches;
+    }
+    async searchSkills(query) {
+        const skillsDir = join(homedir(), ".abbie", "skills");
+        const matches = [];
+        try {
+            const entries = await readdir(skillsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (entry.name === "components" || entry.name === "runbooks")
+                    continue;
+                const skillPath = join(skillsDir, entry.name, "SKILL.md");
+                try {
+                    const content = await readFile(skillPath, "utf-8");
+                    // Parse frontmatter for description
+                    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+                    let description = entry.name;
+                    if (frontmatterMatch) {
+                        const descMatch = frontmatterMatch[1].match(/description:\s*(.+)/);
+                        if (descMatch) {
+                            description = descMatch[1].trim();
+                        }
+                    }
+                    const searchText = `${entry.name} ${description}`;
+                    const score = this.calculateScore(searchText, query);
+                    if (score > 20) {
+                        matches.push({
+                            type: "skill",
+                            name: entry.name,
+                            description,
+                            score,
+                            usage: `Use skill: /${entry.name}`,
+                        });
+                    }
+                }
+                catch {
+                    // Skill file doesn't exist or can't be read
+                }
+            }
+        }
+        catch {
+            // Skills directory doesn't exist
+        }
+        return matches;
+    }
+    async searchPrompts(query) {
+        const matches = [];
+        try {
+            const output = execSync("prompts commands list --json --quiet 2>/dev/null", {
+                encoding: "utf-8",
+            });
+            const prompts = JSON.parse(output);
+            for (const prompt of prompts) {
+                const searchText = `${prompt.alias || prompt.id} ${prompt.title || ""}`;
+                const score = this.calculateScore(searchText, query);
+                if (score > 20) {
+                    matches.push({
+                        type: "prompt",
+                        name: prompt.alias || prompt.id,
+                        description: prompt.title || prompt.id,
+                        score,
+                        usage: `prompts commands export ${prompt.alias || prompt.id}`,
+                    });
+                }
+            }
+        }
+        catch {
+            // prompts CLI not available
+        }
+        return matches;
+    }
+    async searchRoles(query) {
+        const matches = [];
+        try {
+            const output = execSync("roles list --json --quiet 2>/dev/null", { encoding: "utf-8" });
+            const categories = JSON.parse(output);
+            for (const [category, roles] of Object.entries(categories)) {
+                if (!Array.isArray(roles))
+                    continue;
+                for (const role of roles) {
+                    const searchText = `${role.name} ${role.description || ""} ${category}`;
+                    const score = this.calculateScore(searchText, query);
+                    if (score > 20) {
+                        matches.push({
+                            type: "role",
+                            name: role.name,
+                            description: `${role.description || role.name} (${category})`,
+                            score,
+                            usage: `roles export ${role.name}`,
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // roles CLI not available
+        }
+        return matches;
+    }
+}

package/dist/cli/commands/gc.d.ts

@@ -0,0 +1,29 @@
+import { BaseCommand } from "../base-command.js";
+interface GcResult {
+    dryRun: boolean;
+    deleted: number;
+    freedBytes: number;
+    details: Array<{
+        path: string;
+        type: string;
+        ageMs: number;
+        sizeBytes: number;
+        deleted: boolean;
+    }>;
+}
+export default class GcCommand extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "dry-run": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        days: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<GcResult>;
+}
+export {};
+//# sourceMappingURL=gc.d.ts.map

package/dist/cli/commands/gc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gc.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/gc.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,UAAU,QAAQ;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC,CAAC;CACJ;AAED,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,WAAW;IAChD,OAAgB,OAAO,SAAiC;IAExD,OAAgB,WAAW,SAOY;IAEvC,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,KAAK;;;;;;;MAWnB;cAEc,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;CA+L7C"}