@creativeintelligence/abbie 0.1.4 → 0.1.6

package/src/cli/commands/backlog/add.ts

@@ -1,74 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { getBacklogManager } from "../../../lib/backlog.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class BacklogAdd extends BaseCommand {
-  static override description = "Add an item to the backlog";
-  static override hidden = false;
-
-  static override examples = [
-    '<%= config.bin %> backlog add hostagent --ref ZO-123 --title "Fix auth bug"',
-    '<%= config.bin %> backlog add hostagent --ref task-1 --title "Refactor API" --type task --priority 2',
-    '<%= config.bin %> backlog add hostagent --ref "#456" --title "PR review" --type pr --source github',
-  ];
-
-  static override args = {
-    project: Args.string({
-      description: "Project name",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    ref: Flags.string({
-      char: "r",
-      description: "Reference (e.g., ZO-123, #456)",
-      required: true,
-    }),
-    title: Flags.string({
-      char: "t",
-      description: "Item title",
-      required: true,
-    }),
-    type: Flags.string({
-      description: "Item type",
-      options: ["issue", "pr", "task"],
-      default: "task",
-    }),
-    priority: Flags.integer({
-      char: "p",
-      description: "Priority (1=urgent, 4=low)",
-      default: 3,
-    }),
-    source: Flags.string({
-      char: "s",
-      description: "Source",
-      options: ["linear", "github", "manual"],
-      default: "manual",
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(BacklogAdd);
-    this.parsedFlags = flags;
-
-    const backlog = getBacklogManager();
-
-    const item = backlog.add({
-      type: flags.type as "issue" | "pr" | "task",
-      ref: flags.ref,
-      title: flags.title,
-      project: args.project,
-      priority: flags.priority,
-      source: flags.source as "linear" | "github" | "manual",
-    });
-
-    if (flags.json || flags.format === "json") {
-      return item;
-    }
-
-    this.logInfo(`Added: ${item.ref} (${item.id})`);
-    return item;
-  }
-}

package/src/cli/commands/backlog/claim.ts

@@ -1,53 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { getBacklogManager } from "../../../lib/backlog.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class BacklogClaim extends BaseCommand {
-  static override description = "Claim a backlog item for a session";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> backlog claim hostagent ITEM_ID --session SESSION_ID",
-    "<%= config.bin %> backlog claim hostagent ITEM_ID --session SESSION_ID --json",
-  ];
-
-  static override args = {
-    project: Args.string({
-      description: "Project name",
-      required: true,
-    }),
-    item_id: Args.string({
-      description: "Item ID to claim",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      char: "s",
-      description: "Session ID claiming the item",
-      required: true,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(BacklogClaim);
-    this.parsedFlags = flags;
-
-    const backlog = getBacklogManager();
-    const result = backlog.claim(args.project, args.item_id, flags.session);
-
-    if (flags.json || flags.format === "json") {
-      return result;
-    }
-
-    if (result.success) {
-      this.logInfo(`Claimed: ${result.item?.ref}`);
-    } else {
-      this.logInfo(`Failed to claim: ${result.reason}`);
-    }
-
-    return result;
-  }
-}

package/src/cli/commands/backlog/complete.ts

@@ -1,51 +0,0 @@
-import { Args } from "@oclif/core";
-import { getBacklogManager } from "../../../lib/backlog.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class BacklogComplete extends BaseCommand {
-  static override description = "Mark a backlog item as complete";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> backlog complete hostagent ITEM_ID",
-    "<%= config.bin %> backlog complete hostagent ITEM_ID --json",
-  ];
-
-  static override args = {
-    project: Args.string({
-      description: "Project name",
-      required: true,
-    }),
-    item_id: Args.string({
-      description: "Item ID to complete",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(BacklogComplete);
-    this.parsedFlags = flags;
-
-    const backlog = getBacklogManager();
-    const item = backlog.complete(args.project, args.item_id);
-
-    if (!item) {
-      if (flags.json || flags.format === "json") {
-        return { success: false, reason: "Item not found" };
-      }
-      this.logInfo("Item not found");
-      return { success: false };
-    }
-
-    if (flags.json || flags.format === "json") {
-      return { success: true, item };
-    }
-
-    this.logInfo(`Completed: ${item.ref}`);
-    return { success: true, item };
-  }
-}

package/src/cli/commands/backlog/list.ts

@@ -1,107 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { getBacklogManager } from "../../../lib/backlog.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class BacklogList extends BaseCommand {
-  static override description = "List backlog items for a project";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> backlog list hostagent",
-    "<%= config.bin %> backlog list hostagent --status pending",
-    "<%= config.bin %> backlog list hostagent --json",
-  ];
-
-  static override args = {
-    project: Args.string({
-      description: "Project name",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    status: Flags.string({
-      char: "s",
-      description: "Filter by status",
-      options: ["pending", "claimed", "in_progress", "blocked", "completed", "abandoned"],
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(BacklogList);
-    this.parsedFlags = flags;
-
-    const backlog = getBacklogManager();
-    let items = backlog.listItems(args.project);
-
-    if (flags.status) {
-      items = items.filter((item) => item.status === flags.status);
-    }
-
-    if (flags.json || flags.format === "json") {
-      return items;
-    }
-
-    // NDJSON: one item per line
-    if (this.ndjsonEnabled()) {
-      this.outputNdjson(items);
-      return items;
-    }
-
-    if (items.length === 0) {
-      this.logInfo(`No items in ${args.project} backlog`);
-      return [];
-    }
-
-    this.logInfo(`${args.project} backlog (${items.length} items):\n`);
-
-    for (const item of items) {
-      const statusIcon = this.getStatusIcon(item.status);
-      const priorityIcon = this.getPriorityIcon(item.priority);
-
-      this.log(`${statusIcon} ${item.ref}: ${item.title}`);
-      this.log(`   ${priorityIcon} Priority ${item.priority} | Source: ${item.source}`);
-      if (item.claimed_by) {
-        this.log(`   Claimed by: ${item.claimed_by}`);
-      }
-      this.log("");
-    }
-
-    return items;
-  }
-
-  private getStatusIcon(status: string): string {
-    switch (status) {
-      case "pending":
-        return "⏳";
-      case "claimed":
-        return "🔒";
-      case "in_progress":
-        return "🚀";
-      case "blocked":
-        return "🔴";
-      case "completed":
-        return "✅";
-      case "abandoned":
-        return "❌";
-      default:
-        return "•";
-    }
-  }
-
-  private getPriorityIcon(priority: number): string {
-    switch (priority) {
-      case 1:
-        return "🔥";
-      case 2:
-        return "⚡";
-      case 3:
-        return "📌";
-      case 4:
-        return "📋";
-      default:
-        return "•";
-    }
-  }
-}

package/src/cli/commands/backlog/pick.ts

@@ -1,50 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { getBacklogManager } from "../../../lib/backlog.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class BacklogPick extends BaseCommand {
-  static override description = "Pick and claim the next available backlog item";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> backlog pick hostagent --session SESSION_ID",
-    "<%= config.bin %> backlog pick hostagent --session SESSION_ID --json",
-  ];
-
-  static override args = {
-    project: Args.string({
-      description: "Project name",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      char: "s",
-      description: "Session ID claiming the item",
-      required: true,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(BacklogPick);
-    this.parsedFlags = flags;
-
-    const backlog = getBacklogManager();
-    const result = backlog.pickNext(args.project, flags.session);
-
-    if (flags.json || flags.format === "json") {
-      return result;
-    }
-
-    if (result.success && result.item) {
-      this.logInfo(`Picked: ${result.item.ref} - ${result.item.title}`);
-      this.log(result.item.id);
-    } else {
-      this.logInfo(result.reason || "No items available");
-    }
-
-    return result;
-  }
-}

package/src/cli/commands/backlog/sync.ts

@@ -1,131 +0,0 @@
-import { execSync } from "node:child_process";
-import { Args, Flags } from "@oclif/core";
-import { getBacklogManager } from "../../../lib/backlog.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class BacklogSync extends BaseCommand {
-  static override description = "Sync backlog from Linear or GitHub";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> backlog sync hostagent --source linear --team ZO",
-    "<%= config.bin %> backlog sync hostagent --source github --repo owner/repo",
-    '<%= config.bin %> backlog sync hostagent --source linear --team ZO --state "Ready"',
-  ];
-
-  static override args = {
-    project: Args.string({
-      description: "Project name",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    source: Flags.string({
-      char: "s",
-      description: "Source to sync from",
-      required: true,
-      options: ["linear", "github"],
-    }),
-    team: Flags.string({
-      char: "t",
-      description: "Linear team (required for linear source)",
-    }),
-    repo: Flags.string({
-      char: "r",
-      description: "GitHub repo (required for github source)",
-    }),
-    state: Flags.string({
-      description: "Linear state filter",
-      default: "Ready",
-    }),
-    workspace: Flags.string({
-      char: "w",
-      description: "Linear workspace",
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(BacklogSync);
-    this.parsedFlags = flags;
-
-    const backlog = getBacklogManager();
-    let added = 0;
-
-    if (flags.source === "linear") {
-      if (!flags.team) {
-        this.error("--team is required for linear source");
-      }
-
-      const issues = this.fetchLinearIssues(flags.team, flags.state, flags.workspace);
-      added = backlog.syncFromLinear(args.project, issues);
-    } else if (flags.source === "github") {
-      if (!flags.repo) {
-        this.error("--repo is required for github source");
-      }
-
-      const items = this.fetchGitHubItems(flags.repo);
-      added = backlog.syncFromGitHub(args.project, items);
-    }
-
-    const result = { source: flags.source, added };
-
-    if (flags.json || flags.format === "json") {
-      return result;
-    }
-
-    this.logInfo(`Synced from ${flags.source}: ${added} items added`);
-    return result;
-  }
-
-  private fetchLinearIssues(
-    team: string,
-    state: string,
-    workspace?: string,
-  ): Array<{ id: string; title: string; priority: number; identifier: string }> {
-    try {
-      const wsFlag = workspace ? `--workspace ${workspace}` : "";
-      const cmd = `linear issue list --team ${team} --state "${state}" ${wsFlag} --json --quiet`;
-      const output = execSync(cmd, { encoding: "utf-8" });
-      const issues = JSON.parse(output);
-
-      return issues.map(
-        (issue: { id: string; title: string; priority?: number; identifier: string }) => ({
-          id: issue.id,
-          title: issue.title,
-          priority: issue.priority || 3,
-          identifier: issue.identifier,
-        }),
-      );
-    } catch {
-      return [];
-    }
-  }
-
-  private fetchGitHubItems(
-    repo: string,
-  ): Array<{ number: number; title: string; type: "issue" | "pr" }> {
-    try {
-      // Fetch issues
-      const issuesCmd = `gh issue list --repo ${repo} --json number,title --limit 50`;
-      const issuesOutput = execSync(issuesCmd, { encoding: "utf-8" });
-      const issues = JSON.parse(issuesOutput).map((i: { number: number; title: string }) => ({
-        ...i,
-        type: "issue" as const,
-      }));
-
-      // Fetch PRs
-      const prsCmd = `gh pr list --repo ${repo} --json number,title --limit 50`;
-      const prsOutput = execSync(prsCmd, { encoding: "utf-8" });
-      const prs = JSON.parse(prsOutput).map((p: { number: number; title: string }) => ({
-        ...p,
-        type: "pr" as const,
-      }));
-
-      return [...issues, ...prs];
-    } catch {
-      return [];
-    }
-  }
-}

package/src/cli/commands/bootstrap.ts

@@ -1,205 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { basename, join } from "node:path";
-import { Flags } from "@oclif/core";
-import { BaseCommand } from "../base-command.js";
-
-export default class Bootstrap extends BaseCommand {
-  static override description = "Bootstrap .abbie directory using Claude to explore and configure";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> bootstrap",
-    "<%= config.bin %> bootstrap --path ~/Developer/apps/arbor",
-    "<%= config.bin %> bootstrap --if-missing",
-    "<%= config.bin %> bootstrap --dry-run",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    path: Flags.string({
-      char: "p",
-      description: "Project path (default: cwd)",
-    }),
-    "if-missing": Flags.boolean({
-      description: "Only bootstrap if .abbie does not exist",
-      default: false,
-    }),
-    "dry-run": Flags.boolean({
-      description: "Preview prompt without running Claude",
-      default: false,
-    }),
-    force: Flags.boolean({
-      char: "f",
-      description: "Overwrite existing .abbie directory",
-      default: false,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(Bootstrap);
-    this.parsedFlags = flags;
-
-    const projectPath = flags.path || process.cwd();
-    const agentsDir = join(projectPath, ".abbie");
-    const projectName = basename(projectPath);
-
-    // Check if already exists
-    if (existsSync(agentsDir) && !flags.force) {
-      if (flags["if-missing"]) {
-        this.logInfo(`✓ .abbie already exists at ${agentsDir}`);
-        return { status: "skipped", reason: "already exists", path: agentsDir };
-      }
-      this.error(`.abbie already exists at ${agentsDir}. Use --force to overwrite.`);
-    }
-
-    // Load projects.json for emoji/team hints
-    let projectHints = "";
-    const projectsPath = join(process.env.HOME || "", ".abbie", "projects.json");
-    if (existsSync(projectsPath)) {
-      try {
-        const projects = JSON.parse(readFileSync(projectsPath, "utf-8"));
-        const proj = projects.projects?.[projectName];
-        if (proj) {
-          projectHints = `Known project: emoji=${proj.emoji}, linearTeam=${proj.linearTeam || "none"}`;
-        }
-      } catch {
-        // ignore
-      }
-    }
-
-    const prompt = this.buildPrompt(projectPath, projectName, agentsDir, projectHints);
-
-    if (flags["dry-run"]) {
-      this.logInfo("=== DRY RUN - Would send this prompt to Claude ===\n");
-      this.log(prompt);
-      return { status: "dry-run", prompt };
-    }
-
-    // Create .abbie directory
-    mkdirSync(agentsDir, { recursive: true });
-
-    this.logInfo(`Bootstrapping ${projectName} with Claude...`);
-
-    try {
-      const result = await this.runClaude(prompt, projectPath);
-      this.logInfo(`✓ Bootstrap complete for ${projectName}`);
-      return {
-        status: "completed",
-        project: projectName,
-        path: projectPath,
-        agentsDir,
-        claudeOutput: result,
-      };
-    } catch (err) {
-      this.error(`Bootstrap failed: ${(err as Error).message}`);
-    }
-  }
-
-  private buildPrompt(
-    projectPath: string,
-    projectName: string,
-    agentsDir: string,
-    hints: string,
-  ): string {
-    return `Bootstrap .abbie directory for this project.
-
-Project: ${projectName}
-Path: ${projectPath}
-${hints}
-
-## Your task
-
-1. Explore this project:
-   - Run \`ls -la\` to see structure
-   - Check for package.json, Cargo.toml, go.mod, *.xcodeproj, etc.
-   - If monorepo, check subdirectories
-   - Look at recent git history: \`git log --oneline -5\`
-
-2. Create ${agentsDir}/config.json with:
-   - name: project name
-   - emoji: from hints or pick appropriate one
-   - team: Linear team key (from hints) or null
-   - workspace: "luke-labs"
-   - type: what kind of project (e.g., "convex-next", "swift-ios", "rust-cli")
-   - stack: { runtime, framework, database } - only what's actually used
-   - commands: { dev, test, lint, build } - actual commands from package.json/Makefile
-   - quality_gates: what must pass before commit
-
-3. Create ${agentsDir}/context.md (~300 tokens max) with:
-   - Brief project description
-   - Key directories and their purpose
-   - Important patterns or conventions
-   - How to find active work (Linear team, git log)
-
-## Important
-
-- Use ACTUAL values from the project, not assumptions
-- Check package.json scripts for real commands
-- If pnpm-lock.yaml exists, use pnpm. If yarn.lock, use yarn. etc.
-- Write the files directly using the Write tool
-- Keep context.md concise - it's loaded on every agent session`;
-  }
-
-  private async runClaude(prompt: string, cwd: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      // Write prompt to temp file to avoid arg length issues
-      const promptFile = `/tmp/bootstrap-prompt-${Date.now()}.md`;
-      require("node:fs").writeFileSync(promptFile, prompt);
-
-      // Use --print mode, read prompt from stdin
-      const child = spawn(
-        "claude",
-        [
-          "--print",
-          "--permission-mode",
-          "bypassPermissions",
-          "--allowedTools",
-          "Write,Read,Bash,Glob",
-        ],
-        {
-          stdio: ["pipe", "pipe", "pipe"],
-          cwd,
-        },
-      );
-
-      let stdout = "";
-      let stderr = "";
-
-      child.stdout.on("data", (data) => {
-        stdout += data.toString();
-      });
-
-      child.stderr.on("data", (data) => {
-        stderr += data.toString();
-      });
-
-      child.on("close", (code) => {
-        // Clean up prompt file
-        try {
-          require("node:fs").unlinkSync(promptFile);
-        } catch {
-          /* ignore */
-        }
-
-        if (code === 0) {
-          resolve(stdout);
-        } else {
-          reject(new Error(`claude exited with code ${code}: ${stderr}`));
-        }
-      });
-
-      child.on("error", reject);
-
-      // Send prompt via stdin
-      child.stdin.write(prompt);
-      child.stdin.end();
-
-      // Timeout after 180s (Claude needs time to explore and write)
-      setTimeout(() => {
-        child.kill();
-        reject(new Error("claude timeout"));
-      }, 180000);
-    });
-  }
-}