@creativeintelligence/abbie 0.1.0

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

@@ -0,0 +1,266 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Args, Flags } from "@oclif/core";
+import { getActiveSessionManager } from "../../../lib/active-sessions.js";
+import {
+  getReferenceDir,
+  normalizeReferenceJson,
+  parseUrl,
+  type Reference,
+} from "../../../lib/references.js";
+import { BaseCommand } from "../../base-command.js";
+
+export default class ReferenceAdd extends BaseCommand {
+  static override description = "Audit a website and add to the reference bank (ref-add)";
+  static override hidden = false;
+
+  static override examples = [
+    "<%= config.bin %> reference add https://pickle.com",
+    "<%= config.bin %> reference add https://stripe.com --name stripe-checkout",
+  ];
+
+  static override args = {
+    url: Args.string({
+      description: "URL to audit",
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    name: Flags.string({
+      char: "n",
+      description: "Reference name (default: derived from URL)",
+    }),
+    force: Flags.boolean({
+      char: "f",
+      description: "Overwrite existing reference.json (does not delete files)",
+      default: false,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { args, flags } = await this.parse(ReferenceAdd);
+    this.parsedFlags = flags;
+
+    const url = args.url;
+
+    const refName = flags.name || deriveReferenceNameFromUrl(url);
+    const refDir = getReferenceDir("web", refName);
+
+    // Avoid partial audits landing in an unexpected directory
+    if (existsSync(refDir) && !flags.force) {
+      this.error(`Reference '${refName}' already exists at ${refDir}. Use --force to overwrite.`, {
+        exit: 1,
+      });
+    }
+
+    // Create directory structure expected by ref-add
+    mkdirSync(join(refDir, "screenshots", "desktop"), { recursive: true });
+    mkdirSync(join(refDir, "screenshots", "mobile"), { recursive: true });
+    mkdirSync(join(refDir, "specialists"), { recursive: true });
+
+    this.logInfo(`📁 Reference directory: ${refDir}`);
+    this.logInfo(`🔍 Starting audit of ${url}...`);
+
+    // Ensure a minimal reference.json exists so `abbie reference list/show` can find it immediately.
+    const baseManifest = this.writeOrUpdateManifest(refDir, { url, name: refName });
+
+    const prompt = buildRefAddPrompt({ url, refDir, refName });
+
+    let resultText = "";
+    try {
+      this.logInfo("🤖 Spawning Claude with ref-add skill...");
+
+      // Use abbie session start --await instead of direct execSync
+      // This provides proper session tracking, no arbitrary timeout, and streaming output
+      const manager = getActiveSessionManager();
+      const result = await manager.start({
+        agent: "claude",
+        project: refName,
+        goal: prompt,
+        cwd: refDir,
+        awaitCompletion: true, // Block until completion - no timeout!
+      });
+
+      if (result.status === "failed") {
+        throw new Error(`Session failed to start: ${result.error || "unknown error"}`);
+      }
+
+      // Read output after completion
+      const session = await manager.getAsync(result.session_id);
+      const outputPath = session?.output_path || result.output_path;
+
+      if (session?.status === "stopped") {
+        throw new Error("Session was stopped before completion");
+      }
+
+      // Read the output text
+      if (outputPath && existsSync(outputPath)) {
+        const raw = readFileSync(outputPath, "utf-8").trim();
+        if (raw) {
+          try {
+            // If JSON, extract text representation
+            const parsed = JSON.parse(raw);
+            resultText = typeof parsed === "string" ? parsed : JSON.stringify(parsed);
+          } catch {
+            resultText = raw;
+          }
+        }
+      }
+
+      // Also check stdout log for Claude output
+      const stdoutPath = outputPath?.replace("-response.json", "-stdout.log");
+      if (stdoutPath && existsSync(stdoutPath)) {
+        const stdout = readFileSync(stdoutPath, "utf-8");
+        if (stdout && !resultText) {
+          resultText = stdout;
+        }
+      }
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.error(`Audit failed: ${message}`);
+    }
+
+    // Post-process reference.json into the canonical site-card schema.
+    const manifestPath = join(refDir, "reference.json");
+    let normalized: Reference = baseManifest;
+    try {
+      const raw = JSON.parse(readFileSync(manifestPath, "utf-8")) as unknown;
+      normalized = normalizeReferenceJson(
+        raw,
+        { type: "web", name: refName, url, created: baseManifest.created },
+        { touchUpdated: true },
+      );
+      writeFileSync(manifestPath, JSON.stringify(normalized, null, 2));
+    } catch {
+      // Best-effort: keep base manifest
+      try {
+        writeFileSync(manifestPath, JSON.stringify(baseManifest, null, 2));
+      } catch {
+        // ignore
+      }
+    }
+
+    const gistMatch = resultText.match(/https:\/\/gist\.github\.com\/[a-zA-Z0-9]+\/[a-f0-9]+/);
+    const mainGist = normalized.gist?.auditUrl || (gistMatch ? gistMatch[0] : null);
+
+    const output = {
+      status: "complete",
+      url,
+      refName,
+      refDir,
+      mainGist,
+    };
+
+    if (flags.json || flags.format === "json") {
+      return output;
+    }
+
+    this.log(`\n✅ Audit complete for ${url}`);
+    this.log(`   Reference: ${refDir}`);
+    if (mainGist) {
+      this.log(`   Main Gist: ${mainGist}`);
+    }
+
+    // Auto-update the master index gist
+    try {
+      this.logInfo("📋 Updating reference bank index...");
+      const { default: ReferenceUpdateIndex } = await import("./update-index.js");
+      const updateCmd = new ReferenceUpdateIndex(this.argv, this.config);
+      await updateCmd.run();
+      this.logInfo("✅ Bank index updated");
+    } catch (err) {
+      // Non-fatal - just log warning
+      this.logWarn(
+        `Could not update bank index: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+
+    return output;
+  }
+
+  private writeOrUpdateManifest(refDir: string, input: { url: string; name: string }): Reference {
+    const manifestPath = join(refDir, "reference.json");
+    let manifest: Reference;
+    const now = new Date().toISOString();
+
+    if (existsSync(manifestPath)) {
+      try {
+        manifest = JSON.parse(readFileSync(manifestPath, "utf-8")) as Reference;
+      } catch {
+        manifest = { name: input.name, url: input.url, type: "web", created: now };
+      }
+      manifest.url = input.url;
+      if (!manifest.domain) {
+        manifest.domain = parseUrl(input.url).domain;
+      }
+      manifest.type = "web";
+      manifest.updated = now;
+    } else {
+      manifest = {
+        name: input.name,
+        domain: parseUrl(input.url).domain,
+        url: input.url,
+        type: "web",
+        created: now,
+      };
+    }
+
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    return manifest;
+  }
+}
+
+function deriveReferenceNameFromUrl(url: string): string {
+  return url
+    .replace(/^https?:\/\//, "")
+    .replace(/\/$/, "")
+    .replace(/\./g, "-")
+    .replace(/\//g, "-");
+}
+
+function buildRefAddPrompt(input: { url: string; refDir: string; refName: string }): string {
+  return `Use the ref-add skill to audit ${input.url}.
+
+Reference directory: ${input.refDir}
+Reference name: ${input.refName}
+
+Execute the full 4-phase workflow:
+1. Photographer captures baseline screenshots (desktop + mobile)
+2. Director analyzes product and UX journey, establishes SHARED_CONTEXT
+3. All specialists (03-12) run in parallel with shared context
+4. Each specialist produces 80-150 line gist with evidence citations
+
+Quality gates:
+- Minimum 80 lines per specialist gist
+- Minimum 3 screenshot evidence citations per specialist
+- Minimum 2 cross-references per specialist (plus Main)
+- All gists must link back to Main Index
+
+Write outputs into the reference directory:
+- AUDIT.md
+- specialists/*.md
+- screenshots/desktop/*.png and screenshots/mobile/*.png (z-*.png)
+- reference.json MUST preserve existing fields and follow this schema (use key "gist", not "gists"):
+  {
+    "name": "${input.refName}",
+    "domain": "${parseUrl(input.url).domain}",
+    "url": "${input.url}",
+    "type": "web",
+    "created": "<ISO timestamp>",
+    "updated": "<ISO timestamp>",
+    "stack": { "framework": "...", "styling": "...", "hosting": "..." },
+    "tags": ["..."],
+    "notes": "brief factual summary",
+    "screenshots": { "desktop": 0, "mobile": 0 },
+    "gist": {
+      "auditUrl": "https://gist.github.com/...",
+      "desktopScreenshotsUrl": "https://gist.github.com/...",
+      "mobileScreenshotsUrl": "https://gist.github.com/...",
+      "specialists": { "typography": "https://gist.github.com/..." }
+    }
+  }
+
+Output the Main Index gist URL when complete.`;
+}

package/src/cli/commands/reference/delete.ts

@@ -0,0 +1,67 @@
+import { Args, Flags } from "@oclif/core";
+import { deleteReference, findReference } from "../../../lib/references.js";
+import { BaseCommand } from "../../base-command.js";
+
+export default class ReferenceDelete extends BaseCommand {
+  static override description = "Delete a reference from the reference bank";
+  static override hidden = false;
+
+  static override examples = [
+    "<%= config.bin %> reference delete old-ref",
+    "<%= config.bin %> reference delete old-ref --force",
+  ];
+
+  static override args = {
+    name: Args.string({
+      description: "Reference name to delete",
+      required: true,
+    }),
+  };
+
+  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(ReferenceDelete);
+    this.parsedFlags = flags;
+
+    const ref = findReference(args.name);
+    if (!ref) {
+      this.error(`Reference '${args.name}' not found`, { exit: 1 });
+    }
+
+    // Show what will be deleted
+    if (!flags.force && !flags.json) {
+      this.logInfo(`About to delete: ${ref.path}`);
+      this.logInfo(`  Type: ${ref.type}`);
+      this.logInfo(`  URL: ${ref.url}`);
+      if (ref.hasAudit) this.logInfo("  Includes: AUDIT.md");
+      if (ref.hasRepo) this.logInfo("  Includes: cloned repo");
+      this.logInfo("");
+      this.logWarn("This action cannot be undone. Use --force to confirm.");
+      return { deleted: false, ref };
+    }
+
+    // Delete
+    const deleted = deleteReference(ref.type, ref.name);
+
+    // JSON output
+    if (flags.json || flags.format === "json") {
+      return { deleted, name: args.name, path: ref.path };
+    }
+
+    if (deleted) {
+      this.logInfo(`✓ Deleted reference '${args.name}'`);
+    } else {
+      this.logWarn(`Failed to delete reference '${args.name}'`);
+    }
+
+    return { deleted, name: args.name };
+  }
+}