@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/cli/commands/session/start.ts

@@ -1,580 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { basename } from "node:path";
-import { api, getHttpClient } from "@creativeintelligence/sdk/convex";
-import { Flags } from "@oclif/core";
-import { type AgentType, getActiveSessionManager } from "../../../lib/active-sessions.js";
-import { telemetry } from "../../../lib/analytics.js";
-import { loadConfigFromPath } from "../../../lib/config-loader.js";
-import { validateOutputContract } from "../../../lib/contracts.js";
-import { getDeviceId } from "../../../lib/device.js";
-import type { ReinjectMode } from "../../../lib/session-artifacts.js";
-import { readSessionResult } from "../../../lib/session-result.js";
-import { extractProjectFromPath } from "../../../lib/tmux/map.js";
-import { AGENTS } from "../../../lib/types.js";
-import { BaseCommand } from "../../base-command.js";
-
-function hasExplicitSkillRouting(goal: string, skills?: string[]): boolean {
-  if (Array.isArray(skills) && skills.length > 0) {
-    return true;
-  }
-
-  // Explicit prompt-level invocation examples: "use convex-god skill"
-  if (/\buse\s+[\w/-]+\s+skill\b/i.test(goal)) {
-    return true;
-  }
-
-  // Skill XML block already present in goal payload.
-  if (/<skill\b[^>]*>[\s\S]*<\/skill>/i.test(goal)) {
-    return true;
-  }
-  // Backwards-compat with earlier wrapper format.
-  if (/<skill_routing>[\s\S]*<\/skill_routing>/i.test(goal)) {
-    return true;
-  }
-
-  return false;
-}
-
-const TRACE_URL_KEYS = ["traceUrl", "trace_url", "braintrustTraceUrl", "braintrust_trace_url"];
-
-const ENCODED_TRAILING_JUNK_RE = /(?:%22|%27|%7d|%7b|%3e|%3c|%29|%5d)+$/i;
-const RAW_TRAILING_JUNK_RE = /[),.;\]}>]+$/;
-const HTML_TRAILING_JUNK_RE = /(?:&quot;|&#34;|&#39;|&gt;|&lt;)+$/i;
-const TRAILING_SLASH_RE = /\/+$/;
-const TRACE_PATH_RE = /\/traces?\//i;
-const TRACE_ID_PATH_RE = /\/traces?\/([^/?#]+)/i;
-const TRACE_CANONICAL_PATH_RE = /(\/traces?\/[^/?#]+).*/i;
-const BRAINTRUST_OBJECT_PATH_RE = /\/object$/i;
-
-function trimTrailingJunk(value: string): string {
-  let next = value.trim();
-
-  while (true) {
-    const trimmed = next
-      .replace(ENCODED_TRAILING_JUNK_RE, "")
-      .replace(HTML_TRAILING_JUNK_RE, "")
-      .replace(RAW_TRAILING_JUNK_RE, "");
-
-    if (trimmed === next) {
-      return trimmed;
-    }
-    next = trimmed;
-  }
-}
-
-function normalizeTraceUrl(candidate: string): string | undefined {
-  const unescaped = candidate.replace(/\\\//g, "/").replace(/&amp;/gi, "&");
-  const trimmed = trimTrailingJunk(unescaped);
-  if (!trimmed) {
-    return undefined;
-  }
-
-  try {
-    const parsed = new URL(trimmed);
-    const hostname = parsed.hostname.toLowerCase();
-    const isBraintrustHost = hostname.includes("braintrust");
-
-    parsed.pathname = trimTrailingJunk(parsed.pathname).replace(TRAILING_SLASH_RE, "");
-    parsed.hash = "";
-
-    const traceMatch = parsed.pathname.match(TRACE_ID_PATH_RE);
-    if (!traceMatch?.[1]) {
-      if (isBraintrustHost && BRAINTRUST_OBJECT_PATH_RE.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;
-    }
-    if (!isBraintrustHost && !TRACE_PATH_RE.test(parsed.pathname)) {
-      return undefined;
-    }
-
-    parsed.search = "";
-    const canonicalPath = parsed.pathname.replace(TRACE_CANONICAL_PATH_RE, "$1");
-    parsed.pathname = canonicalPath;
-
-    return parsed.toString();
-  } catch {
-    return undefined;
-  }
-}
-
-function extractUrlFromText(text: string): string | undefined {
-  const haystack = text.replace(/\\\//g, "/");
-
-  // Some agents wrap long URLs across lines (e.g. ".../app\n  /test/traces/...").
-  // Fold any whitespace that appears between URL path separators.
-  let folded = haystack;
-  while (true) {
-    const next = folded.replace(/(https?:\/\/[^\s<>"')\]]+)\s+\/(?=[^<>\s])/gi, "$1/");
-    if (next === folded) {
-      break;
-    }
-    folded = next;
-  }
-
-  const matches = folded.match(/https?:\/\/[^\s<>"')\]]+/gi);
-  if (!matches) {
-    return undefined;
-  }
-
-  for (const match of matches) {
-    const normalized = normalizeTraceUrl(match);
-    if (normalized) {
-      return normalized;
-    }
-  }
-
-  return undefined;
-}
-
-function extractTraceUrl(value: unknown): string | undefined {
-  const queue: unknown[] = [value];
-  const seen = new Set<unknown>();
-
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current === null || current === undefined) {
-      continue;
-    }
-
-    if (typeof current === "string") {
-      const traceUrl = extractUrlFromText(current);
-      if (traceUrl) {
-        return traceUrl;
-      }
-      continue;
-    }
-
-    if (typeof current !== "object") {
-      continue;
-    }
-    if (seen.has(current)) {
-      continue;
-    }
-    seen.add(current);
-
-    if (Array.isArray(current)) {
-      for (const item of current) {
-        queue.push(item);
-      }
-      continue;
-    }
-
-    const record = current as Record<string, unknown>;
-    for (const key of TRACE_URL_KEYS) {
-      const candidate = record[key];
-      if (typeof candidate !== "string") {
-        continue;
-      }
-      const traceUrl = extractUrlFromText(candidate);
-      if (traceUrl) {
-        return traceUrl;
-      }
-    }
-
-    for (const value of Object.values(record)) {
-      queue.push(value);
-    }
-  }
-
-  return undefined;
-}
-
-export default class SessionStart extends BaseCommand {
-  static override description = "Start and spawn a new agent session";
-  static override hidden = false;
-
-  static override examples = [
-    '<%= config.bin %> session start --agent claude --project hostagent --goal "Implement ARBOR-123"',
-    '<%= config.bin %> session start --agent codex --project yuba --goal "Fix auth bug" --issue YUBA-42',
-    '<%= config.bin %> session start -a copilot -p arbor -g "Add unit tests" --json',
-    '<%= config.bin %> session start --explore -p arbor -g "map auth flow" --json',
-    "cat prompt.md | <%= config.bin %> session start --agent claude --project arbor",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    agent: Flags.string({
-      char: "a",
-      description: "Agent type to spawn",
-      required: false,
-      options: [...AGENTS],
-    }),
-    explore: Flags.boolean({
-      description: "Explore mode - routes to Gemini and forces read-only",
-      default: false,
-    }),
-    project: Flags.string({
-      char: "p",
-      description: "Project name",
-      required: false,
-    }),
-    goal: Flags.string({
-      char: "g",
-      description: "Goal/task for the agent (can also be provided via stdin)",
-    }),
-    model: Flags.string({
-      char: "m",
-      description: "Model to use (overrides agent default)",
-    }),
-    issue: Flags.string({
-      char: "i",
-      description: "Linear issue reference (e.g., ARBOR-123)",
-    }),
-    parent: Flags.string({
-      description: "Parent session ID (for sub-session tracking)",
-    }),
-    reuse: Flags.string({
-      description: "Comma-separated prior session IDs to include as prompt context",
-    }),
-    "reuse-parent": Flags.boolean({
-      description: "Include the parent session artifact in prompt context",
-      default: false,
-    }),
-    "reinject-mode": Flags.string({
-      description: "How much prior session context to inject: off, summary, or full",
-      options: ["off", "summary", "full"],
-      default: "summary",
-    }),
-    cwd: Flags.string({
-      description: "Working directory for the agent",
-    }),
-    "prompt-file": Flags.string({
-      description: "Path to prompt file (instead of --goal)",
-    }),
-    "read-only": Flags.boolean({
-      char: "r",
-      description: "Read-only mode - inject contract forbidding writes",
-      default: false,
-    }),
-    "trace-id": Flags.string({
-      description:
-        "Explicit trace ID for event correlation (defaults to AGENTS_TRACE_ID or generates new)",
-    }),
-    await: Flags.boolean({
-      description: "Wait for session to complete and return output",
-      default: false,
-    }),
-    headless: Flags.boolean({
-      description: "Run as headless subprocess (no terminal window). Default is terminal mode.",
-      default: false,
-    }),
-    "tmux-session": Flags.string({
-      description:
-        'Tmux session name for terminal mode (default: "abbie"). Prevents hijacking your personal tmux.',
-    }),
-    "auto-context": Flags.boolean({
-      description: "Inject recent file_activity from prior sessions as context (default: true)",
-      default: true,
-      allowNo: true,
-    }),
-    skills: Flags.string({
-      char: "s",
-      description: "Skill(s) to route the agent toward (repeatable, e.g. -s loop -s convex-god)",
-      multiple: true,
-    }),
-  };
-
-  /**
-   * Start an agent session.
-   *
-   * Supports goal via:
-   * - `--goal`
-   * - stdin (piped prompt)
-   * - both (combined as: `<goal>\n\n<stdin>`)
-   *
-   * With `--await`, blocks until completion and returns `{ session, await: { status, output } }`.
-   */
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(SessionStart);
-    this.parsedFlags = flags;
-
-    const manager = getActiveSessionManager();
-
-    // Get goal from flag, stdin, or both (combined)
-    // Skills often pipe a prompt AND pass -g for the task label
-    let goal = flags.goal || "";
-    const stdin = await this.readStdin();
-
-    if (stdin) {
-      // If both stdin and --goal provided, combine them
-      // This supports the skill pattern: cat prompt.md | abbie session start -g "task label"
-      if (goal) {
-        goal = `${goal}\n\n${stdin}`;
-      } else {
-        goal = stdin;
-      }
-    }
-
-    if (!goal && !flags["prompt-file"]) {
-      this.error("Goal is required. Provide via --goal, stdin, or --prompt-file");
-    }
-    if (flags["reuse-parent"] && !flags.parent) {
-      this.error("--reuse-parent requires --parent");
-    }
-
-    const resolvedAgent = flags.explore ? "gemini" : flags.agent;
-    if (!resolvedAgent) {
-      this.error("Agent is required. Provide via --agent or use --explore");
-    }
-
-    // Explore mode is always read-only.
-    const resolvedReadOnly = flags["read-only"] || flags.explore;
-
-    const explicitSkillRouting = hasExplicitSkillRouting(goal, flags.skills);
-    if (!explicitSkillRouting) {
-      this.logWarn(
-        "Spawning without explicit skill routing. Recommended: pass -s <skill> or include `use <skill> skill` in the goal.",
-      );
-      telemetry.trackSession("skill-routing-missing", {
-        agent: resolvedAgent,
-        mode: resolvedReadOnly ? "read-only" : "full",
-      });
-    }
-
-    const resolvedCwd = flags.cwd ?? process.cwd();
-
-    // Infer project name if not explicitly provided.
-    // - Prefer .abbie/config.json "name" from nearest ancestor of cwd.
-    // - Otherwise, map to Luke's canonical directory structure:
-    //   ~/Developer/apps/{project}/... or ~/Developer/utils/{project}/...
-    // - Fallback: basename(cwd)
-    const resolvedProject =
-      flags.project ||
-      (() => {
-        try {
-          const loaded = loadConfigFromPath(resolvedCwd);
-          if (loaded?.config?.name) return loaded.config.name;
-        } catch {
-          // ignore
-        }
-
-        return extractProjectFromPath(resolvedCwd) || basename(resolvedCwd) || "unknown";
-      })();
-
-    const reuseSessionIds = [
-      ...(flags.reuse?.split(",") ?? []),
-      ...(flags["reuse-parent"] && flags.parent ? [flags.parent] : []),
-    ]
-      .map((id) => id.trim())
-      .filter((id) => id.length > 0)
-      .filter((id, index, all) => all.indexOf(id) === index);
-    const requestedReinjectMode = flags["reinject-mode"] as ReinjectMode;
-    const reinjectMode: ReinjectMode = reuseSessionIds.length === 0 ? "off" : requestedReinjectMode;
-
-    const result = await manager.start({
-      agent: resolvedAgent as AgentType,
-      project: resolvedProject,
-      goal: goal || "",
-      issue: flags.issue,
-      parentSessionId: flags.parent,
-      reuseSessionIds,
-      reinjectMode,
-      cwd: resolvedCwd,
-      promptFile: flags["prompt-file"],
-      readOnly: resolvedReadOnly,
-      traceId: flags["trace-id"],
-      model: flags.model,
-      awaitCompletion: flags.await, // Use runner foreground mode for --await
-      headless: flags.headless,
-      tmuxSession: flags["tmux-session"], // Defaults to "abbie" if not specified
-      autoContext: flags["auto-context"],
-      skills: flags.skills,
-    });
-
-    if (result.status === "failed") {
-      telemetry.trackSession("blocked", {
-        agent: resolvedAgent,
-        blocker_type: "spawn_failed",
-      });
-      this.error(`Failed to start session: ${result.error}`);
-    }
-
-    // Track successful session spawn
-    telemetry.trackSession("started", {
-      agent: resolvedAgent,
-      mode: resolvedReadOnly ? "read-only" : "full",
-    });
-
-    // Best-effort: also write session record to the shared store (local JSON remains source of truth/fallback)
-    try {
-      const client = getHttpClient();
-      const session = manager.get(result.session_id);
-
-      await client.mutation(api.sessions.create, {
-        sessionId: result.session_id,
-        agent: resolvedAgent as AgentType,
-        project: resolvedProject,
-        goal: goal || undefined,
-        issue: flags.issue,
-        status: session?.status ?? "running",
-        pid: result.pid || undefined,
-        cwd: session?.cwd ?? resolvedCwd,
-        deviceId: getDeviceId(),
-        parentSessionId: flags.parent,
-        traceId: result.trace_id,
-        promptPath: result.prompt_path,
-        outputPath: result.output_path,
-        metadata: {
-          readOnly: resolvedReadOnly,
-          reuseSessionIds,
-          reinjectMode,
-          resultPath: result.result_path,
-        },
-      });
-
-      // If --await completed the session already, also persist an endedAt timestamp.
-      if (session && session.status !== "running") {
-        await client.mutation(api.sessions.update, {
-          sessionId: result.session_id,
-          status: session.status,
-          endedAt: Date.now(),
-        });
-      }
-    } catch (error) {
-      this.logWarn(
-        `Store write failed (continuing with local session files): ${(error as Error).message}`,
-      );
-    }
-
-    const isJson = flags.json || flags.format === "json";
-
-    if (!isJson) {
-      this.log(`Session started: ${result.session_id}`);
-      this.log(`Agent: ${resolvedAgent}`);
-      this.log(`PID: ${result.pid}`);
-      this.log(`Trace ID: ${result.trace_id}`);
-      if (result.read_only) {
-        this.log(`Mode: READ-ONLY`);
-      }
-      if (reuseSessionIds.length > 0 && reinjectMode !== "off") {
-        this.log(`Reinject: ${reinjectMode}`);
-        this.log(`Reuse sessions: ${reuseSessionIds.join(", ")}`);
-      }
-      this.log(`Prompt: ${result.prompt_path}`);
-      this.log(`Output: ${result.output_path}`);
-      this.log(`Result: ${result.result_path}`);
-      this.log("");
-      this.log(`Attach with: abbie session attach ${result.session_id}`);
-      this.log(`Stop with: abbie session stop ${result.session_id}`);
-    }
-
-    if (flags.await) {
-      // When awaitCompletion is true, manager.start() already blocked until completion.
-      // Read canonical result envelope (with legacy fallback for older sessions).
-      const session = manager.get(result.session_id);
-      const resultPath = session?.result_path || result.result_path;
-      const outputPath = session?.output_path || result.output_path;
-
-      let output: unknown;
-      let awaitStatus: "completed" | "stopped" | "failed" = "failed";
-
-      const sessionResult = resultPath ? readSessionResult(resultPath) : null;
-      if (sessionResult) {
-        output = sessionResult;
-        awaitStatus = sessionResult.status;
-      }
-
-      if (!sessionResult && session) {
-        if (session.status === "completed") {
-          awaitStatus = "completed";
-        } else if (session.status === "stopped") {
-          awaitStatus = "stopped";
-        } else {
-          awaitStatus = "failed";
-        }
-      }
-
-      if (!sessionResult && outputPath && existsSync(outputPath)) {
-        const raw = readFileSync(outputPath, "utf-8").trim();
-        if (raw) {
-          try {
-            output = JSON.parse(raw);
-          } catch {
-            output = raw;
-          }
-        }
-      }
-
-      // Validate output against contract schema (warn on invalid, don't block)
-      let contractValidation: { valid: boolean; errors: string[] } | undefined;
-      const contractCandidate =
-        typeof output === "object" &&
-        output !== null &&
-        "output" in output &&
-        typeof (output as { output?: unknown }).output === "object" &&
-        (output as { output?: { parsed?: unknown } }).output?.parsed !== undefined
-          ? (output as { output: { parsed?: unknown } }).output.parsed
-          : output;
-
-      if (typeof contractCandidate === "object" && contractCandidate !== null) {
-        const validation = validateOutputContract(contractCandidate);
-        contractValidation = { valid: validation.valid, errors: validation.errors };
-        if (!validation.valid && !isJson) {
-          this.logWarn(`Output contract validation: ${validation.errors.join(", ")}`);
-        }
-      }
-
-      const sessionTraceUrl = normalizeTraceUrl(session?.trace_url ?? "");
-      const extractedTraceUrl = extractTraceUrl(contractCandidate) ?? extractTraceUrl(output);
-      const traceUrlToPersist = sessionTraceUrl ?? extractedTraceUrl;
-      if (traceUrlToPersist) {
-        try {
-          const client = getHttpClient();
-          await client.mutation(api.sessions.update, {
-            sessionId: result.session_id,
-            traceUrl: traceUrlToPersist,
-            metadata: {
-              trace_url: traceUrlToPersist,
-              traceUrl: traceUrlToPersist,
-              traceUrlSource: sessionTraceUrl ? "runner" : "output",
-            },
-          });
-        } catch (error) {
-          if (!isJson) {
-            this.logWarn(`Failed to persist trace URL: ${(error as Error).message}`);
-          }
-        }
-      }
-
-      const awaitResult = { status: awaitStatus, output, contractValidation };
-      const combined = { session: result, await: awaitResult };
-
-      if (isJson) {
-        return combined;
-      }
-
-      if (awaitResult.status === "stopped") {
-        this.logInfo(`Session ${result.session_id} was stopped`);
-      } else if (awaitResult.status === "failed") {
-        this.logInfo(`Session ${result.session_id} failed`);
-      }
-
-      if (typeof awaitResult.output === "string") {
-        this.log(awaitResult.output);
-      } else if (awaitResult.output !== undefined) {
-        this.log(JSON.stringify(awaitResult.output, null, 2));
-      }
-
-      return combined;
-    }
-
-    if (isJson) {
-      return result;
-    }
-
-    return result;
-  }
-}

package/src/cli/commands/session/state/cleanup.ts

@@ -1,61 +0,0 @@
-import { Flags } from "@oclif/core";
-import { SessionStateManager } from "../../../../lib/session-state.js";
-import { BaseCommand } from "../../../base-command.js";
-
-export default class SessionStateCleanup extends BaseCommand {
-  static override description = "Clean up zombie and old session state records";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> session state cleanup --older-than 7d --json",
-    "<%= config.bin %> session state cleanup --older-than 30d --dry-run --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    "older-than": Flags.string({
-      description: "Delete ended sessions older than this duration (e.g., 7d, 12h, 30m)",
-      default: "7d",
-    }),
-    "dry-run": Flags.boolean({
-      description: "Show what would be changed without modifying the database",
-      default: false,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(SessionStateCleanup);
-    this.parsedFlags = flags;
-
-    const manager = new SessionStateManager();
-    const result = manager.cleanup({
-      olderThan: flags["older-than"],
-      dryRun: flags["dry-run"],
-    });
-
-    if (flags.json || flags.format === "json") {
-      return result;
-    }
-
-    const verb = result.dry_run ? "Would clean" : "Cleaned";
-    this.logInfo(
-      `${verb} session state: ${result.zombies.length} zombies, ${result.deleted.length} deleted`,
-    );
-
-    if (result.zombies.length > 0) {
-      this.logInfo("\nZombies:");
-      for (const s of result.zombies) {
-        this.logInfo(`- ${s.session_id} (pid ${s.pid ?? "?"})`);
-      }
-    }
-
-    if (result.deleted.length > 0) {
-      this.logInfo("\nDeleted:");
-      for (const d of result.deleted) {
-        this.logInfo(`- ${d.session_id} (ended_at ${d.ended_at ?? "?"})`);
-      }
-    }
-
-    return result;
-  }
-}

package/src/cli/commands/session/state/end.ts

@@ -1,47 +0,0 @@
-import { Flags } from "@oclif/core";
-import { SessionStateManager, type SessionStateStatus } from "../../../../lib/session-state.js";
-import { BaseCommand } from "../../../base-command.js";
-
-export default class SessionStateEnd extends BaseCommand {
-  static override description = "End a session state record";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> session state end --session test-123 --status completed --json",
-    "<%= config.bin %> session state end --session test-123 --status failed --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      description: "Session ID",
-      required: true,
-    }),
-    status: Flags.string({
-      description: "End status",
-      options: ["completed", "failed", "stopped"],
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(SessionStateEnd);
-    this.parsedFlags = flags;
-
-    const manager = new SessionStateManager();
-    const record = manager.end({
-      sessionId: flags.session,
-      status: (flags.status as Exclude<SessionStateStatus, "active"> | undefined) ?? "completed",
-    });
-
-    if (!record) {
-      this.error(`Session not found: ${flags.session}`);
-    }
-
-    if (flags.json || flags.format === "json") {
-      return record;
-    }
-
-    this.logInfo(`Ended session: ${record.session_id} (${record.status})`);
-    return record;
-  }
-}