@creativeintelligence/abbie 0.1.0

package/src/cli/commands/preview/stop.ts

@@ -0,0 +1,165 @@
+import { basename, resolve } from "node:path";
+import { getStoredClerkId } from "@abbie/sdk/config";
+import { api, getHttpClient, isConvexConfigured } from "@abbie/sdk/convex";
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+
+interface ActiveServer {
+  _id: string;
+  workspaceId: string;
+  workspaceDisplayName?: string | null;
+  status?: string;
+  name: string;
+}
+
+/**
+ * Stop a preview server.
+ */
+export default class PreviewStop extends BaseCommand {
+  static override description = "Stop a preview server";
+  static override hidden = false;
+
+  static override examples = [
+    "<%= config.bin %> preview stop",
+    "<%= config.bin %> preview stop --project my-app",
+    "<%= config.bin %> preview stop --all",
+    "<%= config.bin %> preview stop --json",
+  ];
+
+  static override args = {
+    project: Args.string({
+      description: "Project name or path (defaults to current directory)",
+    }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    project: Flags.string({
+      char: "p",
+      description: "Project name or path",
+    }),
+    all: Flags.boolean({
+      description: "Stop all running previews",
+      default: false,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { args, flags } = await this.parse(PreviewStop);
+    this.parsedFlags = flags;
+
+    if (!isConvexConfigured()) {
+      this.error("Convex not configured. Set CONVEX_URL or convexUrl in ~/.abbie/config.json");
+    }
+
+    const clerkId = getStoredClerkId();
+    if (!clerkId) {
+      this.error("Not authenticated. Log in via the web UI first.");
+    }
+
+    const isJson = flags.json || flags.format === "json";
+    const http = getHttpClient();
+
+    // Get all active servers
+    const servers = (await http.query(api["functions/sandbox/servers"].listActive, { clerkId })) as
+      ActiveServer[];
+
+    // Stop all
+    if (flags.all) {
+      const results: Array<{
+        project: string;
+        server_id: string;
+        stopped: boolean;
+        error?: string;
+      }> = [];
+
+      for (const server of servers) {
+        const project = server.workspaceDisplayName?.replace("preview-", "") ?? "unknown";
+        try {
+          await http.action(api["functions/sandbox/servers"].stop, {
+            clerkId,
+            workspaceId: server.workspaceId,
+            serverId: server._id,
+          });
+          results.push({ project, server_id: server._id, stopped: true });
+        } catch (err) {
+          results.push({
+            project,
+            server_id: server._id,
+            stopped: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      }
+
+      if (isJson) {
+        return { success: true, stopped: results };
+      }
+
+      if (results.length === 0) {
+        this.logInfo("No running previews found");
+      } else {
+        this.log(`Stopped ${results.filter((r) => r.stopped).length} preview(s):`);
+        for (const r of results) {
+          this.log(`  ${r.project}: ${r.stopped ? "✓" : "✗"} ${r.error || ""}`);
+        }
+      }
+
+      return { success: true, stopped: results };
+    }
+
+    // Stop specific project
+    const projectInput = flags.project || args.project || process.cwd();
+    const projectPath = resolve(projectInput);
+    const projectName = basename(projectPath);
+
+    // Find matching server by workspace display name
+    const match = servers.find((s) => {
+      const wsName = s.workspaceDisplayName ?? "";
+      return (
+        wsName === `preview-${projectName}` ||
+        wsName === projectName ||
+        s.name === `preview-${projectName}`
+      );
+    });
+
+    if (!match) {
+      if (isJson) {
+        return { success: false, error: `No active preview found for ${projectName}` };
+      }
+      this.error(
+        `No active preview found for ${projectName}. Run 'abbie preview list' to see active servers.`,
+      );
+    }
+
+    this.logInfo(`Stopping preview for ${projectName}...`);
+
+    try {
+      await http.action(api["functions/sandbox/servers"].stop, {
+        clerkId,
+        workspaceId: match.workspaceId,
+        serverId: match._id,
+      });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      if (isJson) {
+        return { success: false, project: projectName, error: errorMsg };
+      }
+      this.error(`Failed to stop: ${errorMsg}`);
+    }
+
+    const result = {
+      success: true,
+      project: projectName,
+      server_id: match._id,
+    };
+
+    if (isJson) {
+      return result;
+    }
+
+    this.log(`✓ Stopped preview for ${projectName}`);
+
+    return result;
+  }
+}

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

@@ -0,0 +1,110 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Args, Flags } from "@oclif/core";
+import { findProjectPath } from "../../../lib/config-loader.js";
+import { ensureManagedSession, hasProjectWindow } from "../../../lib/managed-session.js";
+import { BaseCommand } from "../../base-command.js";
+
+export default class ProjectAdd extends BaseCommand {
+  static override description = "Add a project to the managed abbie workspace";
+  static override hidden = false;
+
+  static override examples = [
+    "<%= config.bin %> project add arbor",
+    "<%= config.bin %> project add arbor ~/Developer/apps/arbor/arbor-xyz",
+    "<%= config.bin %> project add arbor --bootstrap",
+  ];
+
+  static override args = {
+    name: Args.string({ required: true, description: "Project name" }),
+    path: Args.string({ required: false, description: "Project path (auto-resolved if omitted)" }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    bootstrap: Flags.boolean({
+      description: "Run bootstrap if .abbie/config.json is missing",
+      default: false,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { args, flags } = await this.parse(ProjectAdd);
+    this.parsedFlags = flags;
+
+    const name = args.name;
+
+    // Ensure the managed abbie tmux session exists
+    const session = await ensureManagedSession();
+
+    // Check if project window already exists
+    if (await hasProjectWindow(name)) {
+      this.error(`Project "${name}" already exists in the ${session} session`);
+    }
+
+    // Resolve project path
+    let projectPath = args.path;
+    if (!projectPath) {
+      projectPath = findProjectPath(name);
+      if (!projectPath) {
+        this.error(
+          `Could not find project "${name}". Provide an explicit path: abbie project add ${name} /path/to/project`,
+        );
+      }
+    }
+
+    if (!existsSync(projectPath)) {
+      this.error(`Path does not exist: ${projectPath}`);
+    }
+
+    // Check for config
+    const configPath = join(projectPath, ".abbie", "config.json");
+    const hasConfig = existsSync(configPath);
+
+    // Create tmux window with nvim
+    const { newWindow } = await import("../../../lib/tmux/bridge.js");
+    await newWindow({
+      name,
+      cwd: projectPath,
+      session,
+      command: "nvim",
+    });
+
+    const isJson = flags.json || flags.format === "json";
+
+    if (!isJson) {
+      this.log(`Added project: ${name}`);
+      this.log(`Path: ${projectPath}`);
+      this.log(`Session: ${session}`);
+      if (!hasConfig) {
+        this.log(`Note: No .abbie/config.json found. Run: abbie bootstrap --path ${projectPath}`);
+      }
+    }
+
+    // Run bootstrap if requested and config missing
+    if (flags.bootstrap && !hasConfig) {
+      this.logInfo(`Bootstrapping .abbie for ${name}...`);
+      const { spawn } = await import("node:child_process");
+      await new Promise<void>((resolve) => {
+        const proc = spawn("abbie", ["bootstrap", "--path", projectPath!], {
+          stdio: "inherit",
+        });
+        proc.on("close", () => resolve());
+      });
+    }
+
+    const result = {
+      name,
+      path: projectPath,
+      session,
+      hasConfig,
+      status: "added" as const,
+    };
+
+    if (isJson) {
+      return result;
+    }
+
+    return result;
+  }
+}

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

@@ -0,0 +1,136 @@
+import { findProject, loadConfigFromPath } from "../../../lib/config-loader.js";
+import { getManagedSessionName, listManagedWindows } from "../../../lib/managed-session.js";
+import { BaseCommand } from "../../base-command.js";
+
+interface ProjectInfo {
+  name: string;
+  path: string;
+  windowIndex: number;
+  hasConfig: boolean;
+  emoji?: string;
+  team?: string;
+}
+
+const INTERNAL_WINDOW_NAMES = new Set(["_abbie"]);
+const INTERNAL_SHELL_COMMANDS = new Set(["zsh", "bash", "fish", "sh"]);
+
+function abbreviateHome(path: string): string {
+  const home = process.env.HOME;
+  if (!home) return path;
+  if (path === home) return "~";
+  if (path.startsWith(`${home}/`)) return `~/${path.slice(home.length + 1)}`;
+  return path;
+}
+
+export default class ProjectList extends BaseCommand {
+  static override description = "List projects in the managed abbie workspace";
+  static override hidden = false;
+
+  static override examples = [
+    "<%= config.bin %> project list",
+    "<%= config.bin %> project list --json --quiet",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { flags } = await this.parse(ProjectList);
+    this.parsedFlags = flags;
+
+    const session = getManagedSessionName();
+    const windows = await listManagedWindows();
+
+    // Enrich each window with project config metadata
+    const projects: ProjectInfo[] = [];
+    for (const win of windows) {
+      // Exclude internal/session bootstrap window from project list
+      if (INTERNAL_WINDOW_NAMES.has(win.name)) continue;
+
+      // Get pane cwd for config lookup
+      let path = "";
+      let currentCommand = "";
+      let hasConfig = false;
+      let emoji: string | undefined;
+      let team: string | undefined;
+
+      try {
+        const { listPanes } = await import("../../../lib/tmux/bridge.js");
+        const panes = await listPanes(win.index, session);
+        if (panes.length > 0) {
+          path = panes[0].currentPath;
+          currentCommand = panes[0].currentCommand;
+        }
+      } catch {
+        // Fall back to discovery
+      }
+
+      // Best-effort heuristic to hide legacy bootstrap windows created before `_abbie`
+      if (
+        win.index === 0 &&
+        INTERNAL_SHELL_COMMANDS.has(currentCommand) &&
+        win.name === currentCommand
+      ) {
+        continue;
+      }
+
+      // Try to load config from pane path
+      if (path) {
+        try {
+          const loaded = loadConfigFromPath(path);
+          if (loaded) {
+            hasConfig = true;
+            emoji = loaded.config.emoji;
+            team = loaded.config.team;
+          }
+        } catch {
+          // No config — fine
+        }
+      }
+
+      // Fall back to project discovery
+      if (!hasConfig) {
+        const discovered = findProject(win.name);
+        if (discovered) {
+          if (!path) path = discovered.path;
+          hasConfig = discovered.hasConfig;
+        }
+      }
+
+      projects.push({
+        name: win.name,
+        path,
+        windowIndex: win.index,
+        hasConfig,
+        emoji,
+        team,
+      });
+    }
+
+    const isJson = flags.json || flags.format === "json";
+
+    if (isJson) {
+      return { session, projects };
+    }
+
+    if (projects.length === 0) {
+      this.log(`No projects in ${session} session`);
+      this.log("");
+      this.log("Add one with: abbie project add <name> [path]");
+      return { session, projects };
+    }
+
+    // Table output
+    this.log(`Projects in ${session} session:\n`);
+    for (const p of projects) {
+      const icon = p.emoji ?? "○";
+      const configMark = p.hasConfig ? "✓" : "-";
+      const teamLabel = p.team ? ` [${p.team}]` : "";
+      this.log(`  ${icon} ${p.name}${teamLabel}  ${abbreviateHome(p.path)}  config:${configMark}`);
+    }
+    this.log(`\n${projects.length} project(s)`);
+
+    return { session, projects };
+  }
+}

package/src/cli/commands/project/remove.ts

@@ -0,0 +1,60 @@
+import { Args, Flags } from "@oclif/core";
+import { getManagedSessionName, listManagedWindows } from "../../../lib/managed-session.js";
+import { BaseCommand } from "../../base-command.js";
+
+export default class ProjectRemove extends BaseCommand {
+  static override description = "Remove a project from the managed abbie workspace";
+  static override hidden = false;
+
+  static override examples = [
+    "<%= config.bin %> project remove arbor",
+    "<%= config.bin %> project remove arbor --force",
+  ];
+
+  static override args = {
+    name: Args.string({ required: true, description: "Project name" }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    force: Flags.boolean({
+      char: "f",
+      description: "Skip confirmation",
+      default: false,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { args, flags } = await this.parse(ProjectRemove);
+    this.parsedFlags = flags;
+
+    const name = args.name;
+    const session = getManagedSessionName();
+
+    // Find the window
+    const windows = await listManagedWindows();
+    const target = windows.find((w) => w.name === name);
+
+    if (!target) {
+      this.error(`Project "${name}" not found in the ${session} session`);
+    }
+
+    // Kill the window
+    const { killWindow } = await import("../../../lib/tmux/bridge.js");
+    await killWindow(target.index, session);
+
+    const isJson = flags.json || flags.format === "json";
+
+    if (!isJson) {
+      this.log(`Removed project: ${name}`);
+    }
+
+    const result = { name, status: "removed" as const };
+
+    if (isJson) {
+      return result;
+    }
+
+    return result;
+  }
+}

package/src/cli/commands/push.ts

@@ -0,0 +1,115 @@
+/**
+ * abbie push — upload local rules/skills/hooks to Convex.
+ *
+ * Default: dry-run showing what would be pushed.
+ * --apply: actually push to Convex.
+ * --type: push specific content type only.
+ */
+
+import { Flags } from "@oclif/core";
+import { api, getHttpClient, isConvexConfigured } from "@abbie/sdk/convex";
+import { getStoredClerkId } from "@abbie/sdk/config";
+import {
+  ContentSyncRunner,
+  type ContentPushResult,
+  type ContentType,
+} from "../../lib/content-sync/index.js";
+import { BaseCommand } from "../base-command.js";
+
+export default class PushCommand extends BaseCommand {
+  static override summary =
+    "Push local rules, skills, and hooks to Convex";
+
+  static override description = `Scans ~/.abbie/rules/, ~/.abbie/skills/, and ~/.abbie/hooks/
+and uploads content to Convex for cross-device sync.
+
+Default mode is dry-run — shows what would be pushed.
+Use --apply to actually push.`;
+
+  static override examples = [
+    "$ abbie push",
+    "$ abbie push --apply",
+    "$ abbie push --type rules --apply",
+    "$ abbie push --type skills --apply",
+    "$ abbie push --json --quiet",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    apply: Flags.boolean({
+      description: "Apply changes (default is dry-run)",
+      default: false,
+    }),
+    type: Flags.string({
+      char: "t",
+      description: "Push specific content type",
+      options: ["rules", "skills", "hooks"],
+    }),
+  };
+
+  async execute(): Promise<ContentPushResult> {
+    const { flags } = await this.parse(PushCommand);
+    this.parsedFlags = flags;
+
+    if (!isConvexConfigured()) {
+      this.logWarn("Convex not configured. Run `abbie login` first.");
+      return { ok: false, pushed: [], errors: [] };
+    }
+
+    const clerkId = getStoredClerkId();
+    if (!clerkId) {
+      this.logWarn("Not authenticated. Run `abbie login` first.");
+      return { ok: false, pushed: [], errors: [] };
+    }
+
+    const dryRun = !flags.apply;
+    const types = flags.type
+      ? [flags.type as ContentType]
+      : (["rules", "skills", "hooks"] as ContentType[]);
+
+    const client = getHttpClient();
+
+    const runner = new ContentSyncRunner({
+      fetchSnapshot: async () => {
+        return await client.query(api.contentSync.getSnapshot, { clerkId });
+      },
+      upsertRule: async (rule) => {
+        await client.mutation(api.contentSync.upsertRule, rule);
+      },
+      upsertSkill: async (skill) => {
+        await client.mutation(api.contentSync.upsertSkill, skill);
+      },
+      upsertHook: async (hook) => {
+        await client.mutation(api.contentSync.upsertHook, hook);
+      },
+    });
+
+    const result = await runner.push(clerkId, { types, dryRun });
+
+    // Format output
+    const isJson = flags.json || flags.format === "json";
+    if (!isJson) {
+      if (dryRun) {
+        this.logInfo("dry-run (use --apply to push changes)");
+      }
+
+      if (result.pushed.length === 0 && result.errors.length === 0) {
+        this.logInfo("nothing to push — no local content found");
+      } else {
+        for (const p of result.pushed) {
+          this.log(`  ✓ ${p.type}/${p.name}: ${p.action}`);
+        }
+        for (const e of result.errors) {
+          this.log(`  ✗ ${e.type}/${e.name}: ${e.error}`);
+        }
+
+        const total = result.pushed.length + result.errors.length;
+        this.logInfo(
+          `${result.pushed.length}/${total} ${dryRun ? "would be pushed" : "pushed"}`,
+        );
+      }
+    }
+
+    return result;
+  }
+}