@creativeintelligence/abbie 0.1.0

package/src/cli/commands/status.ts

@@ -0,0 +1,244 @@
+/**
+ * abbie status — config + content sync health overview.
+ *
+ * Reads local sync state + sidecar manifest, reports:
+ * - Last successful sync time
+ * - Per-agent managed keys + drift detection
+ * - Content sync (rules/skills/hooks) status
+ * - Convex reachability
+ * - Pending changes
+ */
+
+import { existsSync, readFileSync, statSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { Flags } from "@oclif/core";
+import { isConvexConfigured } from "@abbie/sdk/convex";
+import { getStoredClerkId } from "@abbie/sdk/config";
+import { getAdapter, getSyncDir, type SidecarManifest, type ConfigSyncState } from "../../lib/config-sync/index.js";
+import { getLatestBackup } from "../../lib/config-sync/writer.js";
+import type { ContentSyncState, ContentManifest } from "../../lib/content-sync/types.js";
+import { BaseCommand } from "../base-command.js";
+
+type StatusResult = {
+  authenticated: boolean;
+  convexConfigured: boolean;
+  lastSyncAt: number | null;
+  consecutiveFailures: number;
+  agents: {
+    agent: string;
+    configPath: string;
+    configExists: boolean;
+    managedKeys: string[];
+    lastSyncAt: number | null;
+    hasBackup: boolean;
+    drift: boolean;
+  }[];
+  content?: {
+    lastSyncAt: number | null;
+    consecutiveFailures: number;
+    rules: { managed: string[]; lastSyncAt: number | null };
+    skills: { managed: string[]; lastSyncAt: number | null };
+    hooks: { managed: string[]; lastSyncAt: number | null };
+  };
+};
+
+export default class StatusCommand extends BaseCommand {
+  static override summary = "Config sync health overview";
+
+  static override description = `Shows the current state of MCP config sync:
+- Authentication status
+- Last successful sync time
+- Per-agent managed keys and drift detection
+- Backup availability`;
+
+  static override examples = [
+    "$ abbie status",
+    "$ abbie status --json --quiet",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+  };
+
+  async execute(): Promise<StatusResult> {
+    const { flags } = await this.parse(StatusCommand);
+    this.parsedFlags = flags;
+
+    const syncDir = getSyncDir();
+    const statePath = `${syncDir}/config-sync-state.json`;
+    const manifestPath = `${syncDir}/managed-sections.json`;
+
+    // Load state
+    let state: ConfigSyncState = {
+      lastHash: "",
+      lastSuccessAt: 0,
+      consecutiveFailures: 0,
+      nextRetryAt: 0,
+    };
+    if (existsSync(statePath)) {
+      try {
+        state = JSON.parse(readFileSync(statePath, "utf-8"));
+      } catch {
+        // ignore
+      }
+    }
+
+    // Load manifest
+    let manifest: SidecarManifest = {};
+    if (existsSync(manifestPath)) {
+      try {
+        manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+      } catch {
+        // ignore
+      }
+    }
+
+    const authenticated = !!getStoredClerkId();
+    const convexConfigured = isConvexConfigured();
+
+    // Build per-agent status
+    const AGENTS = ["claude", "codex", "copilot", "gemini", "opencode"] as const;
+    const agents = AGENTS.map((agent) => {
+      const adapter = getAdapter(agent);
+      const manifestEntry = manifest[agent];
+      const configPath = adapter?.configPath() ?? "(unknown)";
+      const configFileExists = adapter?.configExists() ?? false;
+      const managedKeys = manifestEntry?.managedKeys ?? [];
+      const lastAgentSyncAt = manifestEntry?.lastSyncAt ?? null;
+      const hasBackup = !!getLatestBackup(agent);
+
+      // Drift detection: check if managed keys in the file match manifest
+      let drift = false;
+      if (adapter && configFileExists && managedKeys.length > 0 && agent !== "opencode") {
+        try {
+          const current = adapter.read();
+          // For JSON adapters, check if managed keys are present
+          const mcpServers = (current as Record<string, unknown>).mcpServers as Record<string, unknown> | undefined;
+          if (mcpServers) {
+            for (const key of managedKeys) {
+              if (!(key in mcpServers)) {
+                drift = true;
+                break;
+              }
+            }
+          }
+        } catch {
+          // Can't read — count as drift
+          drift = true;
+        }
+      }
+
+      return {
+        agent,
+        configPath,
+        configExists: configFileExists,
+        managedKeys,
+        lastSyncAt: lastAgentSyncAt,
+        hasBackup,
+        drift,
+      };
+    });
+
+    // Load content sync state
+    const contentStatePath = `${syncDir}/content-sync-state.json`;
+    const contentManifestPath = `${syncDir}/content-manifest.json`;
+
+    let contentState: ContentSyncState = {
+      lastHash: "",
+      lastSuccessAt: 0,
+      consecutiveFailures: 0,
+      nextRetryAt: 0,
+    };
+    if (existsSync(contentStatePath)) {
+      try {
+        contentState = JSON.parse(readFileSync(contentStatePath, "utf-8"));
+      } catch {
+        // ignore
+      }
+    }
+
+    let contentManifest: ContentManifest = {};
+    if (existsSync(contentManifestPath)) {
+      try {
+        contentManifest = JSON.parse(readFileSync(contentManifestPath, "utf-8"));
+      } catch {
+        // ignore
+      }
+    }
+
+    const content = {
+      lastSyncAt: contentState.lastSuccessAt || null,
+      consecutiveFailures: contentState.consecutiveFailures,
+      rules: {
+        managed: contentManifest.rules?.managedFiles ?? [],
+        lastSyncAt: contentManifest.rules?.lastSyncAt ?? null,
+      },
+      skills: {
+        managed: contentManifest.skills?.managedDirs ?? [],
+        lastSyncAt: contentManifest.skills?.lastSyncAt ?? null,
+      },
+      hooks: {
+        managed: contentManifest.hooks?.managedFiles ?? [],
+        lastSyncAt: contentManifest.hooks?.lastSyncAt ?? null,
+      },
+    };
+
+    const result: StatusResult = {
+      authenticated,
+      convexConfigured,
+      lastSyncAt: state.lastSuccessAt || null,
+      consecutiveFailures: state.consecutiveFailures,
+      agents,
+      content,
+    };
+
+    // Format output
+    const isJson = flags.json || flags.format === "json";
+    if (!isJson) {
+      this.log(`  auth: ${authenticated ? "✓" : "✗ (run abbie login)"}`);
+      this.log(`  convex: ${convexConfigured ? "✓" : "✗ (not configured)"}`);
+
+      if (state.lastSuccessAt) {
+        const ago = Math.round((Date.now() - state.lastSuccessAt) / 1000);
+        this.log(`  last config sync: ${ago}s ago`);
+      } else {
+        this.log("  last config sync: never");
+      }
+
+      if (state.consecutiveFailures > 0) {
+        this.log(`  config failures: ${state.consecutiveFailures} consecutive`);
+      }
+
+      this.log("");
+      this.log("  config sync (MCP connections → agent configs):");
+      for (const a of agents) {
+        const status = a.configExists ? "✓" : "·";
+        const keys = a.managedKeys.length > 0 ? ` [${a.managedKeys.join(", ")}]` : "";
+        const driftMark = a.drift ? " ⚠ drift" : "";
+        const backupMark = a.hasBackup ? "" : " (no backup)";
+        this.log(`    ${status} ${a.agent}: ${a.configPath}${keys}${driftMark}${backupMark}`);
+      }
+
+      this.log("");
+      this.log("  content sync (Convex → ~/.abbie/ rules/skills/hooks):");
+      if (content.lastSyncAt) {
+        const ago = Math.round((Date.now() - content.lastSyncAt) / 1000);
+        this.log(`    last sync: ${ago}s ago`);
+      } else {
+        this.log("    last sync: never");
+      }
+      if (content.consecutiveFailures > 0) {
+        this.log(`    failures: ${content.consecutiveFailures} consecutive`);
+      }
+      const rulesCount = content.rules.managed.length;
+      const skillsCount = content.skills.managed.length;
+      const hooksCount = content.hooks.managed.length;
+      this.log(`    rules: ${rulesCount} managed${rulesCount > 0 ? ` [${content.rules.managed.join(", ")}]` : ""}`);
+      this.log(`    skills: ${skillsCount} managed${skillsCount > 0 ? ` [${content.skills.managed.join(", ")}]` : ""}`);
+      this.log(`    hooks: ${hooksCount} managed${hooksCount > 0 ? ` [${content.hooks.managed.join(", ")}]` : ""}`);
+    }
+
+    return result;
+  }
+}

package/src/cli/commands/sync.ts

@@ -0,0 +1,174 @@
+/**
+ * abbie sync — on-demand sync from Convex to local files.
+ *
+ * Syncs both:
+ * 1. MCP connections → local agent config files (claude, codex, copilot, gemini)
+ * 2. Rules/skills/hooks → ~/.abbie/ local files
+ *
+ * Default: dry-run showing planned changes.
+ * --apply: write changes.
+ * --force: skip hash comparison.
+ * --agent: sync specific agent only (config sync only).
+ * --type: sync specific content type only (content sync only).
+ */
+
+import { Flags } from "@oclif/core";
+import { api, getHttpClient, isConvexConfigured } from "@abbie/sdk/convex";
+import { getStoredClerkId } from "@abbie/sdk/config";
+import { ConfigSyncRunner, type ConfigSyncAgent, type SyncTickResult } from "../../lib/config-sync/index.js";
+import { ContentSyncRunner } from "../../lib/content-sync/index.js";
+import type { ContentSyncTickResult, ContentType } from "../../lib/content-sync/types.js";
+import { BaseCommand } from "../base-command.js";
+
+type CombinedSyncResult = {
+  config: SyncTickResult;
+  content: ContentSyncTickResult;
+};
+
+export default class SyncCommand extends BaseCommand {
+  static override summary = "Sync Convex state to local config and content files";
+
+  static override description = `Syncs two pipelines from Convex to local:
+
+1. Config sync: MCP connections → agent config files
+   (~/.claude/.mcp.json, ~/.codex/config.toml, etc.)
+
+2. Content sync: rules/skills/hooks → ~/.abbie/ files
+   (~/.abbie/rules/*.md, ~/.abbie/skills/*/SKILL.md, ~/.abbie/hooks/*)
+
+Default mode is dry-run — shows what would change without writing.
+Use --apply to actually write the changes.`;
+
+  static override examples = [
+    "$ abbie sync",
+    "$ abbie sync --apply",
+    "$ abbie sync --force --apply",
+    "$ abbie sync --agent claude --apply",
+    "$ abbie sync --type rules --apply",
+    "$ abbie sync --json --quiet",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    apply: Flags.boolean({
+      description: "Apply changes (default is dry-run)",
+      default: false,
+    }),
+    force: Flags.boolean({
+      char: "f",
+      description: "Skip hash comparison, force re-sync",
+      default: false,
+    }),
+    agent: Flags.string({
+      char: "a",
+      description: "Sync specific agent only (config sync)",
+      options: ["claude", "codex", "copilot", "gemini", "opencode"],
+    }),
+    type: Flags.string({
+      char: "t",
+      description: "Sync specific content type only (content sync)",
+      options: ["rules", "skills", "hooks"],
+    }),
+  };
+
+  async execute(): Promise<CombinedSyncResult> {
+    const { flags } = await this.parse(SyncCommand);
+    this.parsedFlags = flags;
+
+    if (!isConvexConfigured()) {
+      this.logWarn("Convex not configured. Run `abbie login` first.");
+      return {
+        config: { ok: false, reason: "convex-not-configured", changes: [] },
+        content: { ok: false, reason: "convex-not-configured", changes: [] },
+      };
+    }
+
+    const clerkId = getStoredClerkId();
+    if (!clerkId) {
+      this.logWarn("Not authenticated. Run `abbie login` first.");
+      return {
+        config: { ok: false, reason: "not-authenticated", changes: [] },
+        content: { ok: false, reason: "not-authenticated", changes: [] },
+      };
+    }
+
+    const dryRun = !flags.apply;
+    const agents = flags.agent ? [flags.agent as ConfigSyncAgent] : undefined;
+    const types = flags.type ? [flags.type as ContentType] : undefined;
+
+    // Set up decrypt function using @lnittman/convex-encryption
+    let decryptFn: ((v: string) => Promise<string>) | undefined;
+    try {
+      const { decryptIfEncrypted } = await import("@lnittman/convex-encryption");
+      decryptFn = async (v: string) => {
+        const result = await decryptIfEncrypted(v);
+        return result ?? v;
+      };
+    } catch {
+      // Encryption package not available — pass through
+    }
+
+    const client = getHttpClient();
+
+    // Config sync (MCP connections → agent config files)
+    const configRunner = new ConfigSyncRunner({
+      fetchSnapshot: async () => {
+        return await client.query(api.configSync.getSnapshot, { clerkId });
+      },
+      decrypt: decryptFn,
+      agents,
+    });
+
+    const configResult = await configRunner.tick({ force: flags.force, dryRun });
+
+    // Content sync (rules/skills/hooks → ~/.abbie/)
+    const contentRunner = new ContentSyncRunner({
+      fetchSnapshot: async () => {
+        return await client.query(api.contentSync.getSnapshot, { clerkId });
+      },
+      types,
+    });
+
+    const contentResult = await contentRunner.tick({ force: flags.force, dryRun });
+
+    // Format output
+    const isJson = flags.json || flags.format === "json";
+    if (!isJson) {
+      if (dryRun) {
+        this.logInfo("dry-run (use --apply to write changes)");
+      }
+
+      // Config sync results
+      this.log("");
+      this.log("  config sync (MCP → agent configs):");
+      if (configResult.reason === "unchanged") {
+        this.log("    no changes");
+      } else {
+        for (const change of configResult.changes) {
+          const icon = change.action === "error" ? "✗" : change.action === "skipped" ? "·" : "✓";
+          const added = change.keysAdded.length > 0 ? ` +${change.keysAdded.join(",")}` : "";
+          const removed = change.keysRemoved.length > 0 ? ` -${change.keysRemoved.join(",")}` : "";
+          const err = change.error ? ` (${change.error})` : "";
+          this.log(`    ${icon} ${change.agent}: ${change.action}${added}${removed}${err}`);
+        }
+      }
+
+      // Content sync results
+      this.log("");
+      this.log("  content sync (Convex → ~/.abbie/):");
+      if (contentResult.reason === "unchanged") {
+        this.log("    no changes");
+      } else if (contentResult.changes.length === 0) {
+        this.log("    no content in Convex");
+      } else {
+        for (const change of contentResult.changes) {
+          const icon = change.action === "error" ? "✗" : change.action === "unchanged" ? "·" : "✓";
+          const err = change.error ? ` (${change.error})` : "";
+          this.log(`    ${icon} ${change.type}/${change.name}: ${change.action}${err}`);
+        }
+      }
+    }
+
+    return { config: configResult, content: contentResult };
+  }
+}

package/src/cli/commands/trace/export.ts

@@ -0,0 +1,255 @@
+import { execSync } from "node:child_process";
+import { writeFileSync } from "node:fs";
+import { Args, Flags } from "@oclif/core";
+import { getActiveSessionManager } from "../../../lib/active-sessions.js";
+import { AgentSessionMiner } from "../../../lib/agent-sessions.js";
+import {
+  type AbbieSessionData,
+  mapToAgentTrace,
+  validateAgentTrace,
+} from "../../../lib/agent-trace.js";
+import { SessionStateManager } from "../../../lib/session-state.js";
+import { BaseCommand } from "../../base-command.js";
+
+function normalizeTraceUrl(candidate: string | undefined): string | undefined {
+  if (!candidate) {
+    return undefined;
+  }
+
+  const normalized = candidate.replace(/\\\//g, "/").replace(/&/gi, "&").trim();
+  if (!normalized) {
+    return undefined;
+  }
+
+  try {
+    const parsed = new URL(normalized);
+    const isBraintrustHost = parsed.hostname.toLowerCase().includes("braintrust");
+
+    parsed.pathname = parsed.pathname
+      .replace(/(?:%22|%27|%7d|%7b|%3e|%3c|%29|%5d)+$/i, "")
+      .replace(/\/+$/, "");
+    parsed.hash = "";
+
+    const traceMatch = parsed.pathname.match(/\/traces?\/([^/?#]+)/i);
+    if (traceMatch?.[1]) {
+      parsed.search = "";
+      parsed.pathname = parsed.pathname.replace(/(\/traces?\/[^/?#]+).*/i, "$1");
+      return parsed.toString();
+    }
+
+    if (isBraintrustHost && /\/object$/i.test(parsed.pathname)) {
+      const objectType = parsed.searchParams.get("object_type");
+      const objectId = parsed.searchParams.get("object_id");
+      const id = parsed.searchParams.get("id");
+      if (!objectType || !objectId || !id) {
+        return undefined;
+      }
+
+      const searchParams = new URLSearchParams();
+      searchParams.set("object_type", objectType);
+      searchParams.set("object_id", objectId);
+      searchParams.set("id", id);
+      parsed.search = `?${searchParams.toString()}`;
+      return parsed.toString();
+    }
+
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export default class TraceExport extends BaseCommand {
+  static override description =
+    "Export a session as an Agent Trace v0.1 record (interoperability format)";
+  static override hidden = false;
+
+  static override examples = [
+    "<%= config.bin %> trace export SESSION_ID",
+    "<%= config.bin %> trace export SESSION_ID --json --quiet",
+    "<%= config.bin %> trace export SESSION_ID --output trace.json",
+    "<%= config.bin %> trace export --last",
+  ];
+
+  static override args = {
+    sessionId: Args.string({
+      description: "Session ID to export (or use --last for most recent)",
+      required: false,
+    }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    last: Flags.boolean({
+      description: "Export the most recent session",
+      default: false,
+    }),
+    output: Flags.string({
+      char: "o",
+      description: "Write trace to file instead of stdout",
+    }),
+    validate: Flags.boolean({
+      description: "Validate output against Agent Trace schema",
+      default: true,
+      allowNo: true,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { args, flags } = await this.parse(TraceExport);
+    this.parsedFlags = flags;
+
+    const isJson = flags.json || flags.format === "json";
+
+    // Resolve session ID
+    let sessionId = args.sessionId;
+    if (flags.last && !sessionId) {
+      sessionId = await this.findLastSession();
+    }
+
+    if (!sessionId) {
+      this.error("Provide a session ID or use --last");
+    }
+
+    // Collect session data from all sources
+    const sessionData = await this.collectSessionData(sessionId);
+    if (!sessionData) {
+      this.error(`No session found for: ${sessionId}`);
+    }
+
+    // Map to Agent Trace
+    const trace = mapToAgentTrace(sessionData);
+
+    // Validate
+    if (flags.validate) {
+      const errors = validateAgentTrace(trace);
+      if (errors.length > 0) {
+        if (!isJson) {
+          this.logWarn(`Validation warnings: ${errors.join("; ")}`);
+        }
+      }
+    }
+
+    // Output
+    const json = JSON.stringify(trace, null, 2);
+
+    if (flags.output) {
+      writeFileSync(flags.output, json);
+      if (!isJson && !flags.quiet) {
+        this.logInfo(`Wrote Agent Trace to ${flags.output}`);
+      }
+    }
+
+    if (isJson) {
+      return trace;
+    }
+
+    if (!flags.output) {
+      this.log(json);
+    }
+
+    return trace;
+  }
+
+  private async findLastSession(): Promise<string | undefined> {
+    const manager = getActiveSessionManager();
+    const sessions = await manager.listAsync();
+
+    // Prefer completed sessions, then any
+    const completed = sessions.filter((s) => s.status === "completed");
+    const target = completed.length > 0 ? completed : sessions;
+
+    if (target.length === 0) return undefined;
+
+    // Sort by started_at descending
+    target.sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime());
+
+    return target[0].session_id;
+  }
+
+  private async collectSessionData(sessionId: string): Promise<AbbieSessionData | null> {
+    // Source 1: Active sessions (store-first with local fallback)
+    const manager = getActiveSessionManager();
+    const active = await manager.getAsync(sessionId);
+
+    // Source 2: Session state (SQLite)
+    let sessionState: {
+      agent?: string;
+      project?: string | null;
+      status?: string;
+      started_at?: string;
+      ended_at?: string | null;
+      metadata?: Record<string, unknown>;
+    } | null = null;
+    try {
+      const stateManager = new SessionStateManager();
+      sessionState = stateManager.get(sessionId);
+    } catch {
+      // SQLite not available
+    }
+
+    // Source 3: Mined sessions (agent-specific session files)
+    const miner = new AgentSessionMiner();
+    let mined: { files_modified?: string[]; commits?: string[]; summary?: string } | null = null;
+    try {
+      const allMined = miner.mineAll();
+      mined = allMined.find((s) => s.id === sessionId) ?? null;
+    } catch {
+      // Mining failed
+    }
+
+    // Source 4: Git commits during session window
+    let gitCommits: string[] = [];
+    const cwd = active?.cwd || (sessionState?.metadata?.cwd as string | undefined);
+    if (cwd) {
+      const startedAt = active?.started_at || sessionState?.started_at;
+      if (startedAt) {
+        try {
+          const out = execSync(`git log --format=%H --since="${startedAt}" 2>/dev/null`, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+          }).trim();
+          if (out) gitCommits = out.split("\n").map((h: string) => h.slice(0, 7));
+        } catch {
+          // Not a git repo
+        }
+      }
+    }
+
+    // Merge all sources
+    const agent = active?.agent || (sessionState?.agent as string) || "unknown";
+    const project = active?.project || (sessionState?.project as string) || null;
+    const metadata = sessionState?.metadata as Record<string, unknown> | undefined;
+    const metadataTraceUrl =
+      (typeof metadata?.traceUrl === "string" ? metadata.traceUrl : undefined) ||
+      (typeof metadata?.trace_url === "string" ? metadata.trace_url : undefined) ||
+      (typeof metadata?.braintrust === "object" &&
+      metadata?.braintrust !== null &&
+      typeof (metadata.braintrust as Record<string, unknown>).trace_url === "string"
+        ? ((metadata.braintrust as Record<string, unknown>).trace_url as string)
+        : undefined);
+    const traceUrl = normalizeTraceUrl(active?.trace_url || metadataTraceUrl);
+
+    if (!active && !sessionState) {
+      return null;
+    }
+
+    return {
+      sessionId,
+      agent,
+      project,
+      status: active?.status || (sessionState?.status as string) || "unknown",
+      startedAt: active?.started_at || sessionState?.started_at || new Date().toISOString(),
+      endedAt: sessionState?.ended_at || null,
+      traceId: active?.trace_id || (sessionState?.metadata?.trace_id as string | undefined),
+      traceUrl,
+      issue: active?.issue || (sessionState?.metadata?.issue as string | undefined),
+      branch: sessionState?.metadata?.git_branch as string | undefined,
+      commits: gitCommits.length > 0 ? gitCommits : mined?.commits,
+      filesModified: mined?.files_modified,
+      model: sessionState?.metadata?.model as string | undefined,
+      cwd,
+    };
+  }
+}