hissuno 0.2.0

package/dist/index.js

@@ -0,0 +1,2921 @@
+// src/index.ts
+import { Command as Command13 } from "commander";
+
+// src/commands/types.ts
+import { Command } from "commander";
+
+// src/lib/output.ts
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var CYAN = "\x1B[36m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var GREEN = "\x1B[32m";
+var MAGENTA = "\x1B[35m";
+function renderMarkdown(text) {
+  return text.split("\n").map((line) => {
+    if (line.startsWith("# ")) return `
+${BOLD}${CYAN}${line.slice(2)}${RESET}
+`;
+    if (line.startsWith("## ")) return `
+${BOLD}${line.slice(3)}${RESET}`;
+    if (line.startsWith("### ")) return `${BOLD}${line.slice(4)}${RESET}`;
+    if (line.startsWith("- **")) {
+      return line.replace(/\*\*([^*]+)\*\*/g, `${BOLD}$1${RESET}`).replace(/`([^`]+)`/g, `${DIM}$1${RESET}`);
+    }
+    if (line.startsWith("_") && line.endsWith("_")) {
+      return `${DIM}${line.slice(1, -1)}${RESET}`;
+    }
+    return line.replace(/\*\*([^*]+)\*\*/g, `${BOLD}$1${RESET}`).replace(/`([^`]+)`/g, `${DIM}$1${RESET}`);
+  }).join("\n");
+}
+function renderJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function success(message) {
+  console.log(`${GREEN}${message}${RESET}`);
+}
+function error(message) {
+  console.error(`${RED}${message}${RESET}`);
+}
+function warn(message) {
+  console.warn(`${YELLOW}${message}${RESET}`);
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+}
+function formatDate(val) {
+  if (!val) return "-";
+  const s = typeof val === "string" ? val : String(val);
+  try {
+    const d = new Date(s);
+    return d.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+  } catch {
+    return s;
+  }
+}
+function label(text) {
+  return `${DIM}${text}${RESET}`;
+}
+function heading(text) {
+  return `${BOLD}${CYAN}${text}${RESET}`;
+}
+function itemName(text) {
+  return `${BOLD}${text}${RESET}`;
+}
+function dimText(text) {
+  return `${DIM}${text}${RESET}`;
+}
+function badge(text, color = YELLOW) {
+  return `${color}${text}${RESET}`;
+}
+function formatResourceList(type, items, total) {
+  const lines = [heading(`${capitalize(type)} (${total} total)`), ""];
+  if (items.length === 0) {
+    lines.push(dimText("No results found."));
+    return lines.join("\n");
+  }
+  for (const item of items) {
+    const name = item.name ?? item.title ?? "Untitled";
+    switch (type) {
+      case "feedback":
+        lines.push(formatFeedbackRow(item, name));
+        break;
+      case "issues":
+        lines.push(formatIssueRow(item, name));
+        break;
+      case "contacts":
+        lines.push(formatContactRow(item, name));
+        break;
+      case "companies":
+        lines.push(formatCompanyRow(item, name));
+        break;
+      case "knowledge":
+        lines.push(formatKnowledgeRow(item, name));
+        break;
+      case "sources":
+        lines.push(formatSourceRow(item, name));
+        break;
+      case "scopes":
+        lines.push(formatScopeRow(item, name));
+        break;
+      default:
+        lines.push(`  ${itemName(name)}  ${dimText(String(item.id ?? ""))}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function formatFeedbackRow(item, name) {
+  const id = dimText(truncate(String(item.id ?? ""), 12));
+  const source = item.source ? badge(String(item.source)) : "";
+  const status = item.status ? label(String(item.status)) : "";
+  const msgs = item.message_count != null ? `${item.message_count} msgs` : "";
+  const tags = Array.isArray(item.tags) && item.tags.length > 0 ? dimText(item.tags.join(", ")) : "";
+  const date = formatDate(item.last_activity_at);
+  const parts = [source, status, msgs, tags, date].filter(Boolean);
+  return `  ${itemName(truncate(name, 40))}  ${id}
+    ${parts.join("  ")}`;
+}
+function formatIssueRow(item, name) {
+  const id = dimText(truncate(String(item.id ?? ""), 12));
+  const type = item.type ? badge(String(item.type), MAGENTA) : "";
+  const priority = item.priority ? formatPriority(String(item.priority)) : "";
+  const status = item.status ? label(String(item.status)) : "";
+  const upvotes = item.upvote_count != null ? `${item.upvote_count} upvotes` : "";
+  const parts = [type, priority, status, upvotes].filter(Boolean);
+  return `  ${itemName(truncate(name, 50))}  ${id}
+    ${parts.join("  ")}`;
+}
+function formatPriority(p) {
+  switch (p) {
+    case "high":
+      return `${RED}high${RESET}`;
+    case "medium":
+      return `${YELLOW}medium${RESET}`;
+    case "low":
+      return `${GREEN}low${RESET}`;
+    default:
+      return label(p);
+  }
+}
+function formatContactRow(item, name) {
+  const email = item.email ? dimText(String(item.email)) : "";
+  const role = item.role ? label(String(item.role)) : "";
+  const title = item.title ? label(String(item.title)) : "";
+  const champion = item.is_champion ? badge("champion", GREEN) : "";
+  const parts = [email, role, title, champion].filter(Boolean);
+  return `  ${itemName(name)}  ${parts.join("  ")}`;
+}
+function formatCompanyRow(item, name) {
+  const id = dimText(truncate(String(item.id ?? ""), 12));
+  const domain = item.domain ? dimText(String(item.domain)) : "";
+  const stage = item.stage ? badge(String(item.stage)) : "";
+  const arr = item.arr != null ? `$${Number(item.arr).toLocaleString()} ARR` : "";
+  const industry = item.industry ? label(String(item.industry)) : "";
+  const health = item.health_score != null ? `health: ${item.health_score}` : "";
+  const contactCount = item.contact_count != null ? `${item.contact_count} contacts` : "";
+  const parts = [domain, stage, arr, industry, health, contactCount].filter(Boolean);
+  return `  ${itemName(name)}  ${id}
+    ${parts.join("  ")}`;
+}
+function formatScopeRow(item, name) {
+  const id = dimText(truncate(String(item.id ?? ""), 12));
+  const type = item.type ? badge(String(item.type), MAGENTA) : "";
+  const isDefault = item.is_default ? badge("default", GREEN) : "";
+  const goals = Array.isArray(item.goals) && item.goals.length > 0 ? `${item.goals.length} goals` : "";
+  const desc = item.description ? dimText(truncate(String(item.description), 40)) : "";
+  const parts = [type, isDefault, goals, desc].filter(Boolean);
+  return `  ${itemName(name)}  ${id}
+    ${parts.join("  ")}`;
+}
+function formatKnowledgeRow(item, name) {
+  const desc = item.description ? dimText(truncate(String(item.description), 60)) : "";
+  const sources = item.sourceCount != null ? `${item.sourceCount} sources` : "";
+  const lastAnalyzed = item.lastAnalyzedAt ? `analyzed ${formatDate(item.lastAnalyzedAt)}` : dimText("not analyzed");
+  const parts = [desc, sources, lastAnalyzed].filter(Boolean);
+  return `  ${itemName(name)}
+    ${parts.join("  ")}`;
+}
+function formatSourceRow(item, name) {
+  const id = dimText(truncate(String(item.id ?? ""), 12));
+  const type = item.type ? badge(String(item.type), MAGENTA) : "";
+  const status = item.status ? label(String(item.status)) : "";
+  const url = item.url ? dimText(truncate(String(item.url), 40)) : "";
+  const analyzed = item.analyzed_at ? `analyzed ${formatDate(item.analyzed_at)}` : dimText("not analyzed");
+  const enabled = item.enabled === false ? badge("disabled", RED) : "";
+  const parts = [type, status, enabled, url, analyzed].filter(Boolean);
+  return `  ${itemName(truncate(name, 40))}  ${id}
+    ${parts.join("  ")}`;
+}
+function formatResourceDetail(type, item, extra) {
+  const name = item.name ?? item.title ?? "Untitled";
+  const lines = [heading(name), ""];
+  if (item.id) lines.push(`${label("ID:")} ${item.id}`);
+  switch (type) {
+    case "feedback":
+      formatFeedbackDetail(lines, item, extra);
+      break;
+    case "issues":
+      formatIssueDetail(lines, item);
+      break;
+    case "contacts":
+      formatContactDetail(lines, item);
+      break;
+    case "companies":
+      formatCompanyDetail(lines, item);
+      break;
+    case "knowledge":
+      formatKnowledgeDetail(lines, item);
+      break;
+    case "sources":
+      formatSourceDetail(lines, item);
+      break;
+    case "scopes":
+      formatScopeDetail(lines, item);
+      break;
+  }
+  return lines.join("\n");
+}
+function formatFeedbackDetail(lines, item, extra) {
+  if (item.source) lines.push(`${label("Source:")} ${item.source}`);
+  if (item.status) lines.push(`${label("Status:")} ${item.status}`);
+  if (item.message_count != null) lines.push(`${label("Messages:")} ${item.message_count}`);
+  if (Array.isArray(item.tags) && item.tags.length > 0) lines.push(`${label("Tags:")} ${item.tags.join(", ")}`);
+  if (item.created_at) lines.push(`${label("Created:")} ${formatDate(item.created_at)}`);
+  const messages = extra?.messages ?? item.messages;
+  if (messages && messages.length > 0) {
+    lines.push("", heading("Conversation"), "");
+    for (const msg of messages) {
+      const role = msg.sender_type === "user" || msg.role === "user" ? "Customer" : "Agent";
+      lines.push(`${BOLD}${role}:${RESET} ${msg.content}`, "");
+    }
+  }
+}
+function formatIssueDetail(lines, item) {
+  if (item.type) lines.push(`${label("Type:")} ${item.type}`);
+  if (item.priority) lines.push(`${label("Priority:")} ${formatPriority(String(item.priority))}`);
+  if (item.status) lines.push(`${label("Status:")} ${item.status}`);
+  if (item.upvote_count != null) lines.push(`${label("Upvotes:")} ${item.upvote_count}`);
+  if (item.created_at) lines.push(`${label("Created:")} ${formatDate(item.created_at)}`);
+  if (item.description) {
+    lines.push("", String(item.description));
+  }
+}
+function formatContactDetail(lines, item) {
+  if (item.email) lines.push(`${label("Email:")} ${item.email}`);
+  if (item.role) lines.push(`${label("Role:")} ${item.role}`);
+  if (item.title && typeof item.title === "string") lines.push(`${label("Title:")} ${item.title}`);
+  if (item.phone) lines.push(`${label("Phone:")} ${item.phone}`);
+  if (item.is_champion) lines.push(`${label("Champion:")} ${badge("Yes", GREEN)}`);
+  if (item.company_name || item.company) {
+    const name = item.company_name ?? item.company?.name;
+    if (name) lines.push(`${label("Company:")} ${name}`);
+  }
+  if (item.session_count != null) lines.push(`${label("Feedback sessions:")} ${item.session_count}`);
+  if (item.issue_count != null) lines.push(`${label("Issues:")} ${item.issue_count}`);
+}
+function formatCompanyDetail(lines, item) {
+  if (item.domain) lines.push(`${label("Domain:")} ${item.domain}`);
+  if (item.industry) lines.push(`${label("Industry:")} ${item.industry}`);
+  if (item.country) lines.push(`${label("Country:")} ${item.country}`);
+  if (item.arr != null) lines.push(`${label("ARR:")} $${Number(item.arr).toLocaleString()}`);
+  if (item.stage) lines.push(`${label("Stage:")} ${badge(String(item.stage))}`);
+  if (item.plan_tier) lines.push(`${label("Plan:")} ${item.plan_tier}`);
+  if (item.employee_count != null) lines.push(`${label("Employees:")} ${item.employee_count}`);
+  if (item.health_score != null) lines.push(`${label("Health Score:")} ${item.health_score}`);
+  if (item.renewal_date) lines.push(`${label("Renewal:")} ${formatDate(item.renewal_date)}`);
+  if (item.notes) lines.push(`${label("Notes:")} ${item.notes}`);
+  if (item.created_at) lines.push(`${label("Created:")} ${formatDate(item.created_at)}`);
+  const companyContacts = item.contacts;
+  if (companyContacts && companyContacts.length > 0) {
+    lines.push("", `${BOLD}Contacts (${companyContacts.length}):${RESET}`);
+    for (const c of companyContacts) {
+      lines.push(`  - ${c.name} (${c.email})`);
+    }
+  }
+}
+function formatScopeDetail(lines, item) {
+  if (item.slug) lines.push(`${label("Slug:")} ${item.slug}`);
+  if (item.type) lines.push(`${label("Type:")} ${item.type}`);
+  if (item.is_default) lines.push(`${label("Default:")} ${badge("Yes", GREEN)}`);
+  if (item.description) lines.push(`${label("Description:")} ${item.description}`);
+  if (item.created_at) lines.push(`${label("Created:")} ${formatDate(item.created_at)}`);
+  const goals = item.goals;
+  if (goals && goals.length > 0) {
+    lines.push("", `${BOLD}Goals (${goals.length}):${RESET}`);
+    for (const goal of goals) {
+      lines.push(`  - ${goal.text}`);
+    }
+  }
+}
+function formatKnowledgeDetail(lines, item) {
+  if (item.description) lines.push(`${label("Description:")} ${item.description}`);
+  if (item.sourceCount != null) lines.push(`${label("Sources:")} ${item.sourceCount}`);
+  if (item.lastAnalyzedAt) lines.push(`${label("Last analyzed:")} ${formatDate(item.lastAnalyzedAt)}`);
+  if (item.compiled_at) lines.push(`${label("Compiled:")} ${formatDate(item.compiled_at)}`);
+  const sources = item.sources;
+  if (sources && sources.length > 0) {
+    lines.push("", `${BOLD}Sources:${RESET}`);
+    for (const src of sources) {
+      const parts = [src.type, src.status].filter(Boolean).join(" - ");
+      lines.push(`  - ${src.name ?? "Unnamed"}${parts ? ` (${parts})` : ""}`);
+    }
+  }
+}
+function formatSourceDetail(lines, item) {
+  if (item.type) lines.push(`${label("Type:")} ${badge(String(item.type), MAGENTA)}`);
+  if (item.status) lines.push(`${label("Status:")} ${item.status}`);
+  if (item.enabled !== void 0) lines.push(`${label("Enabled:")} ${item.enabled ? badge("Yes", GREEN) : badge("No", RED)}`);
+  if (item.url) lines.push(`${label("URL:")} ${item.url}`);
+  if (item.description) lines.push(`${label("Description:")} ${item.description}`);
+  if (item.analysis_scope) lines.push(`${label("Analysis scope:")} ${item.analysis_scope}`);
+  if (item.analyzed_at) lines.push(`${label("Analyzed:")} ${formatDate(item.analyzed_at)}`);
+  if (item.created_at) lines.push(`${label("Created:")} ${formatDate(item.created_at)}`);
+  if (item.product_scope_id) lines.push(`${label("Product scope:")} ${item.product_scope_id}`);
+}
+function formatSearchResults(results) {
+  const lines = [heading(`Search Results (${results.length} found)`), ""];
+  if (results.length === 0) {
+    lines.push(dimText("No results found."));
+    return lines.join("\n");
+  }
+  for (const r of results) {
+    const typeTag = badge(`[${r.type}]`, MAGENTA);
+    const score = r.score != null ? dimText(`${Math.round(r.score * 100)}%`) : "";
+    lines.push(`  ${typeTag} ${itemName(r.name)}  ${score}`);
+    lines.push(`    ${dimText(r.id)}`);
+    if (r.snippet) lines.push(`    ${truncate(r.snippet, 80)}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatRelatedEntities(relationships) {
+  const sections = [];
+  const labelMap = {
+    companies: "Companies",
+    contacts: "Contacts",
+    issues: "Issues",
+    sessions: "Feedback",
+    knowledgeSources: "Knowledge",
+    productScopes: "Product Scopes"
+  };
+  for (const [key, items] of Object.entries(relationships)) {
+    if (!Array.isArray(items) || items.length === 0) continue;
+    const lbl = labelMap[key] ?? key;
+    const names = items.map((i) => i.name ?? i.title ?? i.id).join(", ");
+    sections.push(`    ${lbl}: ${names}`);
+  }
+  if (sections.length === 0) return "";
+  return `
+  Related:
+${sections.join("\n")}`;
+}
+function formatResourceTypes() {
+  return [
+    heading("Hissuno Resource Types"),
+    "",
+    `${BOLD}knowledge${RESET}`,
+    "  Knowledge packages (grouped, compiled knowledge bundles).",
+    `  ${label("Filters:")} (none)`,
+    `  ${label("Search:")} Semantic vector search across all knowledge chunks`,
+    "",
+    `${BOLD}sources${RESET}`,
+    "  Individual knowledge sources (codebases, documents, URLs, Notion pages).",
+    `  ${label("Filters:")} (none)`,
+    "",
+    `${BOLD}feedback${RESET}`,
+    "  Customer feedback sessions (conversations from widget, Slack, Intercom, etc.).",
+    `  ${label("Filters:")} --source, --status, --tags, --contact-id, --search`,
+    `  ${label("Search:")} Semantic vector search (full-text fallback)`,
+    `  ${label("Add:")} messages (required), name, tags`,
+    "",
+    `${BOLD}issues${RESET}`,
+    "  Product issues (bugs, feature requests, change requests).",
+    `  ${label("Filters:")} --issue-type, --priority, --status, --search`,
+    `  ${label("Search:")} Semantic vector search for similar issues`,
+    `  ${label("Add:")} type, title, description (required), priority`,
+    "",
+    `${BOLD}customers${RESET}`,
+    "  Customers (contacts and companies). Use --customer-type to select (default: contacts).",
+    `  ${label("Sub-types:")} contacts (people), companies (organizations)`,
+    `  ${label("Filters (contacts):")} --search, --company-id, --role`,
+    `  ${label("Filters (companies):")} --search, --stage, --industry`,
+    `  ${label("Search:")} Semantic vector search (contacts only, name/email fallback)`,
+    `  ${label("Add (contacts):")} name, email (required), role, title, phone, company_id, is_champion`,
+    `  ${label("Add (companies):")} name, domain (required), industry, arr, stage, employee_count, plan_tier, country, notes`,
+    "",
+    `${BOLD}scopes${RESET}`,
+    "  Product scopes (product areas and initiatives) with goals.",
+    `  ${label("Add:")} name, type (required), description, goals`,
+    `  ${label("Update:")} name, type, description, goals`
+  ].join("\n");
+}
+
+// src/commands/types.ts
+var RESOURCE_TYPE_DEFINITIONS = {
+  knowledge: {
+    description: "Knowledge packages (grouped, compiled knowledge bundles).",
+    filters: [],
+    search: "Semantic vector search across all knowledge chunks",
+    add: null
+  },
+  sources: {
+    description: "Individual knowledge sources (codebases, documents, URLs, Notion pages).",
+    filters: [],
+    search: null,
+    add: null
+  },
+  feedback: {
+    description: "Customer feedback sessions (conversations from widget, Slack, Intercom, etc.).",
+    filters: ["source", "status", "tags", "contact_id", "search"],
+    search: "Semantic vector search (full-text fallback)",
+    add: { required: ["messages"], optional: ["name", "tags"] }
+  },
+  issues: {
+    description: "Product issues (bugs, feature requests, change requests).",
+    filters: ["type", "priority", "status", "search"],
+    search: "Semantic vector search for similar issues",
+    add: { required: ["type", "title", "description"], optional: ["priority"] }
+  },
+  customers: {
+    description: "Customers (contacts and companies). Use --customer-type to select (default: contacts).",
+    filters: ["customer_type", "search", "company_id", "role", "stage", "industry"],
+    search: "Semantic vector search (contacts only, name/email fallback)",
+    add: {
+      contacts: { required: ["name", "email"], optional: ["role", "title", "phone", "company_id", "is_champion"] },
+      companies: { required: ["name", "domain"], optional: ["industry", "arr", "stage", "employee_count", "plan_tier", "country", "notes"] }
+    }
+  },
+  scopes: {
+    description: "Product scopes (product areas and initiatives) with goals.",
+    filters: [],
+    search: null,
+    add: { required: ["name", "type"], optional: ["description", "goals"] },
+    update: { optional: ["name", "type", "description", "goals"] }
+  }
+};
+var typesCommand = new Command("types").description("List all available resource types and their filters").action(async (_opts, cmd) => {
+  const jsonMode = cmd.parent?.opts().json;
+  if (jsonMode) {
+    console.log(renderJson(RESOURCE_TYPE_DEFINITIONS));
+  } else {
+    console.log(formatResourceTypes());
+  }
+});
+
+// src/commands/list.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var PROFILE_NAME_RE = /^[a-z0-9-]+$/;
+var CONFIG_DIR = join(homedir(), ".hissuno");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function isMultiProfileConfig(raw) {
+  return "profiles" in raw && typeof raw.profiles === "object";
+}
+function parseLegacyProfile(parsed) {
+  if (!parsed.api_key) return null;
+  let baseUrl = parsed.base_url;
+  if (!baseUrl && parsed.endpoint) {
+    baseUrl = new URL(parsed.endpoint).origin;
+  }
+  if (!baseUrl) return null;
+  return {
+    api_key: parsed.api_key,
+    base_url: baseUrl,
+    ...parsed.project_id ? { project_id: parsed.project_id } : {},
+    ...parsed.username ? { username: parsed.username } : {}
+  };
+}
+function readRawConfig() {
+  if (!existsSync(CONFIG_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeRawConfig(raw) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+}
+function loadConfig() {
+  const raw = readRawConfig();
+  if (!raw) return null;
+  try {
+    if (isMultiProfileConfig(raw)) {
+      const profile = raw.profiles[raw.active_profile];
+      if (!profile) return null;
+      return { ...profile };
+    }
+    return parseLegacyProfile(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  const raw = readRawConfig();
+  if (raw && isMultiProfileConfig(raw)) {
+    raw.profiles[raw.active_profile] = {
+      api_key: config.api_key,
+      base_url: config.base_url,
+      ...config.project_id ? { project_id: config.project_id } : {},
+      ...config.username ? { username: config.username } : {}
+    };
+    writeRawConfig(raw);
+  } else {
+    writeRawConfig(config);
+  }
+}
+function requireConfig() {
+  const config = loadConfig();
+  if (!config) {
+    console.error("Not configured. Run `hissuno config` to set up your API key and URL.");
+    process.exit(1);
+  }
+  return config;
+}
+function loadFullConfig() {
+  const raw = readRawConfig();
+  if (!raw) return null;
+  if (isMultiProfileConfig(raw)) return raw;
+  const legacy = parseLegacyProfile(raw);
+  if (!legacy) return null;
+  return {
+    active_profile: "default",
+    profiles: { default: legacy }
+  };
+}
+function getActiveProfileName() {
+  const raw = readRawConfig();
+  if (raw && isMultiProfileConfig(raw)) return raw.active_profile;
+  return "default";
+}
+function setActiveProfile(name) {
+  const full = loadFullConfig();
+  if (!full) throw new Error("No configuration found. Run `hissuno config` first.");
+  if (!full.profiles[name]) throw new Error(`Profile "${name}" does not exist.`);
+  full.active_profile = name;
+  writeRawConfig(full);
+}
+function createProfile(name, config) {
+  validateProfileName(name);
+  let full = loadFullConfig();
+  if (!full) {
+    full = { active_profile: name, profiles: {} };
+  }
+  if (full.profiles[name]) throw new Error(`Profile "${name}" already exists.`);
+  full.profiles[name] = config;
+  writeRawConfig(full);
+}
+function deleteProfile(name) {
+  const full = loadFullConfig();
+  if (!full) throw new Error("No configuration found.");
+  if (!full.profiles[name]) throw new Error(`Profile "${name}" does not exist.`);
+  if (full.active_profile === name) throw new Error(`Cannot delete the active profile "${name}". Switch to another profile first.`);
+  delete full.profiles[name];
+  writeRawConfig(full);
+}
+function migrateToMultiProfile() {
+  const raw = readRawConfig();
+  if (raw && isMultiProfileConfig(raw)) return raw;
+  const legacy = raw ? parseLegacyProfile(raw) : null;
+  const full = {
+    active_profile: "default",
+    profiles: legacy ? { default: legacy } : {}
+  };
+  writeRawConfig(full);
+  return full;
+}
+function validateProfileName(name) {
+  if (!name) throw new Error("Profile name is required.");
+  if (name.length > 30) throw new Error("Profile name must be 30 characters or fewer.");
+  if (!PROFILE_NAME_RE.test(name)) throw new Error("Profile name must contain only lowercase letters, numbers, and hyphens.");
+}
+
+// src/lib/api.ts
+function getBaseUrl(config) {
+  return config.base_url;
+}
+async function resolveProjectId(config) {
+  if (config.project_id) return config.project_id;
+  const result = await apiCall(config, "GET", "/api/projects");
+  const projects = Array.isArray(result.data) ? result.data : result.data?.projects;
+  if (!result.ok || !Array.isArray(projects) || projects.length === 0) {
+    error("Could not determine project from API key.");
+    process.exit(1);
+  }
+  const projectId = projects[0].id;
+  config.project_id = projectId;
+  saveConfig(config);
+  return projectId;
+}
+function buildPath(path7, params) {
+  const entries = Object.entries(params).filter(
+    (entry) => entry[1] !== void 0
+  );
+  if (entries.length === 0) return path7;
+  const qs = entries.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+  return `${path7}?${qs}`;
+}
+async function apiCall(config, method, path7, body) {
+  const baseUrl = getBaseUrl(config);
+  const url = `${baseUrl}${path7}`;
+  const headers = {
+    Authorization: `Bearer ${config.api_key}`
+  };
+  if (body) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const data = await response.json().catch(() => ({}));
+  return { ok: response.ok, status: response.status, data };
+}
+
+// src/lib/customer-type.ts
+var CUSTOMER_TYPES = ["contacts", "companies"];
+function resolveCustomerType(opt) {
+  const ct = opt ?? "contacts";
+  if (!CUSTOMER_TYPES.includes(ct)) {
+    error(`Invalid customer type "${ct}". Must be one of: ${CUSTOMER_TYPES.join(", ")}`);
+    process.exit(1);
+  }
+  return ct;
+}
+
+// src/commands/list.ts
+var TYPE_ENDPOINTS = {
+  knowledge: { path: "/api/knowledge/packages", key: "packages" },
+  sources: { path: "/api/knowledge/sources", key: "sources" },
+  feedback: { path: "/api/sessions", key: "sessions" },
+  issues: { path: "/api/issues", key: "issues" },
+  customers: { path: "/api/contacts", key: "contacts" },
+  scopes: { path: "/api/product-scopes", key: "scopes" }
+};
+var listCommand = new Command2("list").description("List resources of a given type").argument("<type>", "Resource type: knowledge, sources, feedback, issues, customers, scopes").option("--source <source>", "Filter feedback by source (widget|slack|intercom|gong|api|manual)").option("--status <status>", "Filter by status").option("--tags <tags>", "Filter feedback by tags (comma-separated)").option("--contact-id <id>", "Filter feedback by contact ID").option("--search <query>", "Text search filter").option("--issue-type <type>", "Filter issues by type (bug|feature_request|change_request)").option("--priority <priority>", "Filter issues by priority (low|medium|high)").option("--company-id <id>", "Filter contacts by company ID").option("--role <role>", "Filter contacts by role").option("--customer-type <type>", "Customer sub-type: contacts (default) or companies").option("--stage <stage>", "Filter companies by stage (prospect|onboarding|active|churned|expansion)").option("--industry <industry>", "Filter companies by industry").option("--limit <n>", "Max results (default: 20)", "20").action(async (type, opts, cmd) => {
+  const config = requireConfig();
+  const jsonMode = cmd.parent?.opts().json;
+  const validTypes = Object.keys(TYPE_ENDPOINTS);
+  if (!validTypes.includes(type)) {
+    error(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`);
+    process.exit(1);
+  }
+  const projectId = await resolveProjectId(config);
+  let endpoint;
+  let displayType = type;
+  if (type === "customers") {
+    const customerType = resolveCustomerType(opts.customerType);
+    endpoint = { path: `/api/${customerType}`, key: customerType };
+    displayType = customerType;
+  } else {
+    endpoint = TYPE_ENDPOINTS[type];
+  }
+  const params = {
+    projectId,
+    limit: parseInt(opts.limit, 10)
+  };
+  if (opts.source) params.source = opts.source;
+  if (opts.status) params.status = opts.status;
+  if (opts.tags) params.tags = opts.tags;
+  if (opts.contactId) params.contactId = opts.contactId;
+  if (opts.search) params.search = opts.search;
+  if (opts.issueType) params.type = opts.issueType;
+  if (opts.priority) params.priority = opts.priority;
+  if (opts.companyId) params.companyId = opts.companyId;
+  if (opts.role) params.role = opts.role;
+  if (opts.stage) params.stage = opts.stage;
+  if (opts.industry) params.industry = opts.industry;
+  try {
+    const result = await apiCall(config, "GET", buildPath(endpoint.path, params));
+    if (!result.ok) {
+      const data = result.data;
+      error(`Failed: ${data.error || `HTTP ${result.status}`}`);
+      process.exit(1);
+    }
+    const items = result.data[endpoint.key] ?? [];
+    const total = result.data.total ?? items.length;
+    if (jsonMode) {
+      console.log(renderJson(result.data));
+    } else {
+      console.log(formatResourceList(displayType, items, total));
+    }
+  } catch (err) {
+    error(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/get.ts
+import { Command as Command3 } from "commander";
+function cliTypeToEntityType(type, customerType) {
+  if (type === "customers") {
+    return customerType === "companies" ? "company" : "contact";
+  }
+  const map = {
+    issue: "issue",
+    issues: "issue",
+    session: "session",
+    sessions: "session",
+    feedback: "session",
+    company: "company",
+    companies: "company",
+    contact: "contact",
+    contacts: "contact",
+    knowledge: "knowledge_source",
+    sources: "knowledge_source",
+    scopes: "product_scope",
+    scope: "product_scope"
+  };
+  return map[type] ?? type;
+}
+var TYPE_ENDPOINTS2 = {
+  knowledge: { path: (id) => `/api/knowledge/packages/${id}`, key: "package" },
+  sources: { path: (id) => `/api/knowledge/sources/${id}`, key: "source" },
+  feedback: { path: (id) => `/api/sessions/${id}`, key: "session" },
+  issues: { path: (id) => `/api/issues/${id}`, key: "issue" },
+  customers: { path: (id) => `/api/contacts/${id}`, key: "contact" },
+  scopes: { path: (id) => `/api/product-scopes/${id}`, key: "scope" }
+};
+var getCommand = new Command3("get").description("Get full details of a specific resource").argument("<type>", "Resource type: knowledge, sources, feedback, issues, customers, scopes").argument("<id>", "Resource ID").option("--customer-type <type>", "Customer sub-type: contacts (default) or companies").action(async (type, id, opts, cmd) => {
+  const config = requireConfig();
+  const jsonMode = cmd.parent?.opts().json;
+  const validTypes = Object.keys(TYPE_ENDPOINTS2);
+  if (!validTypes.includes(type)) {
+    error(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`);
+    process.exit(1);
+  }
+  const projectId = await resolveProjectId(config);
+  let endpoint;
+  let displayType = type;
+  const customerType = resolveCustomerType(opts.customerType);
+  if (type === "customers") {
+    const key = customerType === "companies" ? "company" : "contact";
+    endpoint = { path: (id2) => `/api/${customerType}/${id2}`, key };
+    displayType = customerType;
+  } else {
+    endpoint = TYPE_ENDPOINTS2[type];
+  }
+  try {
+    const [result, relResult] = await Promise.all([
+      apiCall(
+        config,
+        "GET",
+        buildPath(endpoint.path(id), { projectId })
+      ),
+      apiCall(
+        config,
+        "GET",
+        buildPath("/api/relationships", {
+          projectId,
+          entityType: cliTypeToEntityType(type, customerType),
+          entityId: id
+        })
+      )
+    ]);
+    if (!result.ok) {
+      const data = result.data;
+      error(`Failed: ${data.error || `HTTP ${result.status}`}`);
+      process.exit(1);
+    }
+    const item = result.data[endpoint.key] ?? result.data;
+    if (jsonMode) {
+      const output = { ...result.data };
+      if (relResult.ok && relResult.data.relationships) {
+        output.relationships = relResult.data.relationships;
+      }
+      console.log(renderJson(output));
+    } else {
+      const extra = type === "feedback" ? { messages: result.data.messages } : void 0;
+      let output = formatResourceDetail(displayType, item, extra);
+      if (relResult.ok && relResult.data.relationships) {
+        output += formatRelatedEntities(relResult.data.relationships);
+      }
+      console.log(output);
+    }
+  } catch (err) {
+    error(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/search.ts
+import { Command as Command4 } from "commander";
+var searchCommand = new Command4("search").description("Search across resources using natural language").argument("<query>", "Search query").option("--type <type>", "Limit to one resource type (knowledge|feedback|issues|customers)").option("--limit <n>", "Max results (default: 10)", "10").action(async (query, opts, cmd) => {
+  const config = requireConfig();
+  const jsonMode = cmd.parent?.opts().json;
+  if (opts.type) {
+    const validTypes = ["knowledge", "feedback", "issues", "customers"];
+    if (!validTypes.includes(opts.type)) {
+      error(`Invalid type "${opts.type}". Must be one of: ${validTypes.join(", ")}`);
+      process.exit(1);
+    }
+    if (opts.type === "customers") opts.type = "contacts";
+  }
+  const projectId = await resolveProjectId(config);
+  const params = {
+    projectId,
+    q: query,
+    limit: parseInt(opts.limit, 10)
+  };
+  if (opts.type) params.type = opts.type;
+  try {
+    const result = await apiCall(
+      config,
+      "GET",
+      buildPath("/api/search", params)
+    );
+    if (!result.ok) {
+      const data = result.data;
+      error(`Failed: ${data.error || `HTTP ${result.status}`}`);
+      process.exit(1);
+    }
+    if (jsonMode) {
+      console.log(renderJson(result.data));
+    } else {
+      console.log(formatSearchResults(result.data.results ?? []));
+    }
+  } catch (err) {
+    error(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/add.ts
+import { Command as Command5 } from "commander";
+import { input, select, confirm } from "@inquirer/prompts";
+async function addIssue() {
+  const type = await select({
+    message: "Issue type:",
+    choices: [
+      { value: "bug", name: "Bug" },
+      { value: "feature_request", name: "Feature Request" },
+      { value: "change_request", name: "Change Request" }
+    ]
+  });
+  const title = await input({ message: "Title:", validate: (v) => v.length > 0 || "Required" });
+  const description = await input({ message: "Description:", validate: (v) => v.length > 0 || "Required" });
+  const hasPriority = await confirm({ message: "Set priority?", default: false });
+  let priority;
+  if (hasPriority) {
+    priority = await select({
+      message: "Priority:",
+      choices: [
+        { value: "low", name: "Low" },
+        { value: "medium", name: "Medium" },
+        { value: "high", name: "High" }
+      ]
+    });
+  }
+  return { type, title, description, ...priority ? { priority } : {} };
+}
+async function addContact() {
+  const name = await input({ message: "Name:", validate: (v) => v.length > 0 || "Required" });
+  const email = await input({
+    message: "Email:",
+    validate: (v) => v.includes("@") ? true : "Must be a valid email"
+  });
+  const data = { name, email };
+  const role = await input({ message: "Role (optional):" });
+  if (role) data.role = role;
+  const title = await input({ message: "Title (optional):" });
+  if (title) data.title = title;
+  const phone = await input({ message: "Phone (optional):" });
+  if (phone) data.phone = phone;
+  const companyId = await input({ message: "Company ID (optional):" });
+  if (companyId) data.company_id = companyId;
+  const isChampion = await confirm({ message: "Is champion?", default: false });
+  if (isChampion) data.is_champion = true;
+  return data;
+}
+async function addCompany() {
+  const name = await input({ message: "Company name:", validate: (v) => v.length > 0 || "Required" });
+  const domain = await input({
+    message: "Domain (e.g., acme.com):",
+    validate: (v) => v.length > 0 || "Required"
+  });
+  const data = { name, domain };
+  const industry = await input({ message: "Industry (optional):" });
+  if (industry) data.industry = industry;
+  const arrStr = await input({ message: "ARR (optional, number):" });
+  if (arrStr) data.arr = Number(arrStr);
+  const hasStage = await confirm({ message: "Set stage?", default: false });
+  if (hasStage) {
+    const stage = await select({
+      message: "Stage:",
+      choices: [
+        { value: "prospect", name: "Prospect" },
+        { value: "onboarding", name: "Onboarding" },
+        { value: "active", name: "Active" },
+        { value: "churned", name: "Churned" },
+        { value: "expansion", name: "Expansion" }
+      ]
+    });
+    data.stage = stage;
+  }
+  const employeeCountStr = await input({ message: "Employee count (optional, number):" });
+  if (employeeCountStr) data.employee_count = Number(employeeCountStr);
+  const planTier = await input({ message: "Plan tier (optional):" });
+  if (planTier) data.plan_tier = planTier;
+  const country = await input({ message: "Country (optional):" });
+  if (country) data.country = country;
+  const notes = await input({ message: "Notes (optional):" });
+  if (notes) data.notes = notes;
+  return data;
+}
+async function addScope() {
+  const name = await input({ message: "Name:", validate: (v) => v.length > 0 || "Required" });
+  const type = await select({
+    message: "Type:",
+    choices: [
+      { value: "product_area", name: "Product Area" },
+      { value: "initiative", name: "Initiative" }
+    ]
+  });
+  const description = await input({ message: "Description (optional):" });
+  const data = { name, type };
+  if (description) data.description = description;
+  const addGoals = await confirm({ message: "Add goals?", default: false });
+  if (addGoals) {
+    const goals = [];
+    console.log("Enter goals (empty text to finish).\n");
+    while (goals.length < 10) {
+      const text = await input({
+        message: `Goal ${goals.length + 1} (empty to finish):`
+      });
+      if (!text) break;
+      goals.push({ id: `g_${Date.now()}_${goals.length}`, text });
+    }
+    if (goals.length > 0) data.goals = goals;
+  }
+  return data;
+}
+async function addFeedback() {
+  const messages = [];
+  console.log("Enter conversation messages (at least 1 required). Empty content to finish.\n");
+  let first = true;
+  while (true) {
+    const role = await select({
+      message: `Message ${messages.length + 1} role:`,
+      choices: [
+        { value: "user", name: "User (customer)" },
+        { value: "assistant", name: "Assistant (support)" }
+      ],
+      default: first ? "user" : void 0
+    });
+    const content = await input({
+      message: `Message ${messages.length + 1} content (empty to finish):`
+    });
+    if (!content) break;
+    messages.push({ role, content });
+    first = false;
+  }
+  if (messages.length === 0) {
+    error("At least one message is required.");
+    process.exit(1);
+  }
+  const data = { messages };
+  const name = await input({ message: "Feedback name/title (optional):" });
+  if (name) data.name = name;
+  const tags = await input({ message: "Tags (comma-separated, optional):" });
+  if (tags) data.tags = tags.split(",").map((t) => t.trim());
+  return data;
+}
+var TYPE_ENDPOINTS3 = {
+  feedback: "/api/sessions",
+  issues: "/api/issues",
+  customers: "/api/contacts",
+  scopes: "/api/product-scopes"
+};
+var addCommand = new Command5("add").description("Create a new resource interactively").argument("<type>", "Resource type: feedback, issues, customers, scopes").option("--customer-type <type>", "Customer sub-type: contacts (default) or companies").action(async (type, opts, cmd) => {
+  const config = requireConfig();
+  const jsonMode = cmd.parent?.opts().json;
+  const supportedTypes = Object.keys(TYPE_ENDPOINTS3);
+  if (!supportedTypes.includes(type)) {
+    if (type === "knowledge") {
+      error("Knowledge sources cannot be added via CLI. Use the Hissuno dashboard.");
+    } else {
+      error(`Invalid type "${type}". Must be one of: ${supportedTypes.join(", ")}`);
+    }
+    process.exit(1);
+  }
+  let data;
+  let apiEndpoint = TYPE_ENDPOINTS3[type];
+  switch (type) {
+    case "issues":
+      data = await addIssue();
+      break;
+    case "customers": {
+      let customerType = opts.customerType;
+      if (!customerType) {
+        customerType = await select({
+          message: "Customer type:",
+          choices: [
+            { value: "contacts", name: "Contact (individual person)" },
+            { value: "companies", name: "Company (organization)" }
+          ]
+        });
+      }
+      customerType = resolveCustomerType(customerType);
+      apiEndpoint = `/api/${customerType}`;
+      data = customerType === "companies" ? await addCompany() : await addContact();
+      break;
+    }
+    case "feedback":
+      data = await addFeedback();
+      break;
+    case "scopes":
+      data = await addScope();
+      break;
+    default:
+      error(`Unsupported type: ${type}`);
+      process.exit(1);
+  }
+  const projectId = await resolveProjectId(config);
+  try {
+    const result = await apiCall(
+      config,
+      "POST",
+      buildPath(apiEndpoint, { projectId }),
+      data
+    );
+    if (!result.ok) {
+      const errData = result.data;
+      error(`Failed: ${errData.error || `HTTP ${result.status}`}`);
+      process.exit(1);
+    }
+    if (jsonMode) {
+      console.log(renderJson(result.data));
+    } else {
+      success("\nCreated successfully!");
+      const created = result.data;
+      const resource = created.session ?? created.issue ?? created.contact ?? created.company ?? created.scope ?? created;
+      if (resource.id) {
+        console.log(`ID: ${resource.id}`);
+      }
+    }
+  } catch (err) {
+    error(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/integrate.ts
+import { Command as Command6 } from "commander";
+import { input as input2, select as select2, confirm as confirm2, password } from "@inquirer/prompts";
+
+// src/lib/browser.ts
+import { exec } from "child_process";
+import { platform } from "os";
+function openBrowser(url) {
+  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`);
+}
+
+// src/commands/integrate.ts
+var PLATFORMS = ["intercom", "gong", "zendesk", "slack", "github", "jira", "linear"];
+var OAUTH_PLATFORMS = ["slack", "github", "jira", "linear"];
+var SYNCABLE_PLATFORMS = ["intercom", "gong", "zendesk"];
+var PLATFORM_LABELS = {
+  intercom: "Intercom",
+  gong: "Gong",
+  zendesk: "Zendesk",
+  slack: "Slack",
+  github: "GitHub",
+  jira: "Jira",
+  linear: "Linear"
+};
+async function getProjectId(config) {
+  return resolveProjectId(config);
+}
+async function getStatus(config, platform2, projectId) {
+  return apiCall(config, "GET", `/api/integrations/${platform2}?projectId=${projectId}`);
+}
+function formatStatus(platform2, data) {
+  const lines = [`# ${PLATFORM_LABELS[platform2]}`, ""];
+  const connected = data.connected;
+  lines.push(`**Status:** ${connected ? "Connected" : "Not connected"}`);
+  if (!connected) return lines.join("\n");
+  if (platform2 === "slack") {
+    if (data.workspaceName) lines.push(`**Workspace:** ${data.workspaceName}`);
+    if (data.workspaceDomain) lines.push(`**Domain:** ${data.workspaceDomain}`);
+    if (data.installedByEmail) lines.push(`**Installed by:** ${data.installedByEmail}`);
+  }
+  if (platform2 === "github") {
+    if (data.accountLogin) lines.push(`**Account:** ${data.accountLogin}`);
+    if (data.installedByEmail) lines.push(`**Installed by:** ${data.installedByEmail}`);
+  }
+  if (platform2 === "jira") {
+    if (data.siteUrl) lines.push(`**Site:** ${data.siteUrl}`);
+    if (data.jiraProjectKey) lines.push(`**Project:** ${data.jiraProjectKey}`);
+    if (data.issueTypeName) lines.push(`**Issue Type:** ${data.issueTypeName}`);
+    lines.push(`**Configured:** ${data.isConfigured ? "Yes" : "No"}`);
+    lines.push(`**Auto-sync:** ${data.autoSyncEnabled ? "Enabled" : "Disabled"}`);
+  }
+  if (platform2 === "linear") {
+    if (data.organizationName) lines.push(`**Organization:** ${data.organizationName}`);
+    if (data.teamName) lines.push(`**Team:** ${data.teamName} (${data.teamKey})`);
+    lines.push(`**Configured:** ${data.isConfigured ? "Yes" : "No"}`);
+    lines.push(`**Auto-sync:** ${data.autoSyncEnabled ? "Enabled" : "Disabled"}`);
+  }
+  if (platform2 === "intercom") {
+    if (data.workspaceName) lines.push(`**Workspace:** ${data.workspaceName}`);
+    if (data.authMethod) lines.push(`**Auth Method:** ${data.authMethod}`);
+    if (data.syncFrequency) lines.push(`**Sync Frequency:** ${data.syncFrequency}`);
+    lines.push(`**Sync Enabled:** ${data.syncEnabled ? "Yes" : "No"}`);
+    if (data.lastSyncAt) lines.push(`**Last Sync:** ${data.lastSyncAt}`);
+    if (data.lastSyncStatus) lines.push(`**Last Sync Status:** ${data.lastSyncStatus}`);
+    lines.push(`**Conversations Synced:** ${data.lastSyncConversationsCount ?? 0}`);
+  }
+  if (platform2 === "gong") {
+    if (data.syncFrequency) lines.push(`**Sync Frequency:** ${data.syncFrequency}`);
+    lines.push(`**Sync Enabled:** ${data.syncEnabled ? "Yes" : "No"}`);
+    if (data.lastSyncAt) lines.push(`**Last Sync:** ${data.lastSyncAt}`);
+    if (data.lastSyncStatus) lines.push(`**Last Sync Status:** ${data.lastSyncStatus}`);
+    lines.push(`**Calls Synced:** ${data.lastSyncCallsCount ?? 0}`);
+  }
+  if (platform2 === "zendesk") {
+    if (data.subdomain) lines.push(`**Subdomain:** ${data.subdomain}`);
+    if (data.accountName) lines.push(`**Account:** ${data.accountName}`);
+    if (data.syncFrequency) lines.push(`**Sync Frequency:** ${data.syncFrequency}`);
+    lines.push(`**Sync Enabled:** ${data.syncEnabled ? "Yes" : "No"}`);
+    if (data.lastSyncAt) lines.push(`**Last Sync:** ${data.lastSyncAt}`);
+    if (data.lastSyncStatus) lines.push(`**Last Sync Status:** ${data.lastSyncStatus}`);
+    lines.push(`**Tickets Synced:** ${data.lastSyncTicketsCount ?? 0}`);
+  }
+  const stats = data.stats;
+  if (stats?.totalSynced != null) {
+    lines.push(`**Total Synced:** ${stats.totalSynced}`);
+  }
+  return lines.join("\n");
+}
+async function connectOAuth(config, platform2, projectId) {
+  const appUrl = getBaseUrl(config);
+  const connectUrl = `${appUrl}/projects/${projectId}/integrations?connect=${platform2}`;
+  console.log(`
+Opening browser to connect ${PLATFORM_LABELS[platform2]}...`);
+  console.log(`URL: ${connectUrl}
+`);
+  openBrowser(connectUrl);
+  warn("Complete the authorization in your browser, then press Enter to verify.");
+  await input2({ message: "Press Enter when done..." });
+  const result = await getStatus(config, platform2, projectId);
+  if (result.ok && result.data.connected) {
+    success(`${PLATFORM_LABELS[platform2]} connected successfully!`);
+    return true;
+  }
+  error(`${PLATFORM_LABELS[platform2]} connection not detected. Please try again.`);
+  return false;
+}
+async function connectGong(config, projectId, opts) {
+  const accessKey = opts.accessKey || await input2({ message: "Access Key:", validate: (v) => v.length > 0 || "Required" });
+  const accessKeySecret = opts.accessKeySecret || await password({ message: "Access Key Secret:", mask: "*", validate: (v) => v.length > 0 || "Required" });
+  const baseUrl = opts.baseUrl || await input2({ message: "Base URL:", default: "https://api.gong.io" });
+  const syncFrequency = opts.syncFrequency || await select2({
+    message: "Sync frequency:",
+    choices: [
+      { value: "manual", name: "Manual" },
+      { value: "1h", name: "Every hour" },
+      { value: "6h", name: "Every 6 hours" },
+      { value: "24h", name: "Every 24 hours" }
+    ],
+    default: "24h"
+  });
+  console.log("\nValidating credentials...");
+  const result = await apiCall(config, "POST", "/api/integrations/gong/connect", {
+    projectId,
+    accessKey,
+    accessKeySecret,
+    baseUrl,
+    syncFrequency
+  });
+  if (result.ok) {
+    success("Gong connected successfully!");
+    return true;
+  }
+  const data = result.data;
+  error(`Connection failed: ${data.error || "Unknown error"}`);
+  return false;
+}
+async function connectZendesk(config, projectId, opts) {
+  const subdomain = opts.subdomain || await input2({ message: "Zendesk subdomain (e.g., mycompany):", validate: (v) => v.length > 0 || "Required" });
+  const email = opts.email || await input2({ message: "Admin email:", validate: (v) => v.includes("@") || "Must be a valid email" });
+  const apiToken = opts.apiToken || await password({ message: "API token:", mask: "*", validate: (v) => v.length > 0 || "Required" });
+  const syncFrequency = opts.syncFrequency || await select2({
+    message: "Sync frequency:",
+    choices: [
+      { value: "manual", name: "Manual" },
+      { value: "1h", name: "Every hour" },
+      { value: "6h", name: "Every 6 hours" },
+      { value: "24h", name: "Every 24 hours" }
+    ],
+    default: "24h"
+  });
+  console.log("\nValidating credentials...");
+  const result = await apiCall(config, "POST", "/api/integrations/zendesk/connect", {
+    projectId,
+    subdomain,
+    email,
+    apiToken,
+    syncFrequency
+  });
+  if (result.ok) {
+    success("Zendesk connected successfully!");
+    return true;
+  }
+  const data = result.data;
+  error(`Connection failed: ${data.error || "Unknown error"}`);
+  return false;
+}
+async function connectIntercom(config, projectId, opts) {
+  const method = opts.accessToken ? "token" : await select2({
+    message: "Connection method:",
+    choices: [
+      { value: "token", name: "API Token" },
+      { value: "oauth", name: "OAuth (opens browser)" }
+    ]
+  });
+  if (method === "oauth") {
+    return connectOAuth(config, "intercom", projectId);
+  }
+  const accessToken = opts.accessToken || await password({ message: "Access Token:", mask: "*", validate: (v) => v.length > 0 || "Required" });
+  const syncFrequency = opts.syncFrequency || await select2({
+    message: "Sync frequency:",
+    choices: [
+      { value: "manual", name: "Manual" },
+      { value: "1h", name: "Every hour" },
+      { value: "6h", name: "Every 6 hours" },
+      { value: "24h", name: "Every 24 hours" }
+    ],
+    default: "24h"
+  });
+  console.log("\nValidating credentials...");
+  const result = await apiCall(config, "POST", "/api/integrations/intercom/connect", {
+    projectId,
+    accessToken,
+    syncFrequency
+  });
+  if (result.ok) {
+    success("Intercom connected successfully!");
+    return true;
+  }
+  const data = result.data;
+  error(`Connection failed: ${data.error || "Unknown error"}`);
+  return false;
+}
+async function configureIntegration(config, platform2, projectId) {
+  if (SYNCABLE_PLATFORMS.includes(platform2)) {
+    const syncFrequency = await select2({
+      message: "Sync frequency:",
+      choices: [
+        { value: "manual", name: "Manual" },
+        { value: "1h", name: "Every hour" },
+        { value: "6h", name: "Every 6 hours" },
+        { value: "24h", name: "Every 24 hours" }
+      ]
+    });
+    const result = await apiCall(config, "PATCH", `/api/integrations/${platform2}?projectId=${projectId}`, {
+      syncFrequency
+    });
+    if (result.ok) {
+      success("Settings updated!");
+    } else {
+      const data = result.data;
+      error(`Update failed: ${data.error || "Unknown error"}`);
+    }
+    return;
+  }
+  if (platform2 === "jira" || platform2 === "linear") {
+    const autoSyncEnabled = await confirm2({ message: "Enable auto-sync of issues?", default: true });
+    const result = await apiCall(config, "PATCH", `/api/integrations/${platform2}?projectId=${projectId}`, {
+      autoSyncEnabled
+    });
+    if (result.ok) {
+      success("Settings updated!");
+    } else {
+      const data = result.data;
+      error(`Update failed: ${data.error || "Unknown error"}`);
+    }
+    return;
+  }
+  warn(`${PLATFORM_LABELS[platform2]} is configured through its connection flow or the dashboard.`);
+}
+async function syncIntegration(config, platform2, projectId, mode) {
+  if (!SYNCABLE_PLATFORMS.includes(platform2)) {
+    error(`${PLATFORM_LABELS[platform2]} does not support manual sync.`);
+    return;
+  }
+  const syncMode = mode || await select2({
+    message: "Sync mode:",
+    choices: [
+      { value: "incremental", name: "Incremental (new items only)" },
+      { value: "full", name: "Full (re-sync everything)" }
+    ],
+    default: "incremental"
+  });
+  console.log(`
+Syncing ${PLATFORM_LABELS[platform2]} (${syncMode})...
+`);
+  const baseUrl = getBaseUrl(config);
+  const url = `${baseUrl}/api/integrations/${platform2}/sync?projectId=${projectId}&mode=${syncMode}`;
+  try {
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${config.api_key}` }
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      try {
+        const data = JSON.parse(text);
+        error(`Sync failed: ${data.error || `HTTP ${response.status}`}`);
+      } catch {
+        error(`Sync failed: HTTP ${response.status}`);
+      }
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      error("No response stream.");
+      return;
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        try {
+          const event = JSON.parse(line.slice(6));
+          if (event.type === "progress") {
+            process.stdout.write(`\r  Syncing... ${event.current ?? 0}/${event.total ?? "?"}`);
+          } else if (event.type === "complete") {
+            process.stdout.write("\n");
+            success(event.message || "Sync complete!");
+          } else if (event.type === "error") {
+            process.stdout.write("\n");
+            error(event.message || "Sync error.");
+          }
+        } catch {
+        }
+      }
+    }
+  } catch (err) {
+    error(`Sync failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+  }
+}
+async function disconnectIntegration(config, platform2, projectId) {
+  const confirmed = await confirm2({
+    message: `Disconnect ${PLATFORM_LABELS[platform2]}? This cannot be undone.`,
+    default: false
+  });
+  if (!confirmed) {
+    console.log("Cancelled.");
+    return;
+  }
+  const result = await apiCall(config, "DELETE", `/api/integrations/${platform2}?projectId=${projectId}`);
+  if (result.ok) {
+    success(`${PLATFORM_LABELS[platform2]} disconnected.`);
+  } else {
+    const data = result.data;
+    error(`Disconnect failed: ${data.error || "Unknown error"}`);
+  }
+}
+async function interactiveWizard(config, platform2, projectId, jsonMode) {
+  const statusResult = await getStatus(config, platform2, projectId);
+  if (!statusResult.ok) {
+    const data2 = statusResult.data;
+    error(`Failed to get status: ${data2.error || `HTTP ${statusResult.status}`}`);
+    process.exit(1);
+  }
+  const data = statusResult.data;
+  if (jsonMode) {
+    console.log(renderJson(data));
+    return;
+  }
+  console.log(renderMarkdown(formatStatus(platform2, data)));
+  if (!data.connected) {
+    const shouldConnect = await confirm2({ message: `Connect ${PLATFORM_LABELS[platform2]}?`, default: true });
+    if (shouldConnect) {
+      if (OAUTH_PLATFORMS.includes(platform2)) {
+        await connectOAuth(config, platform2, projectId);
+      } else if (platform2 === "gong") {
+        await connectGong(config, projectId, {});
+      } else if (platform2 === "zendesk") {
+        await connectZendesk(config, projectId, {});
+      } else if (platform2 === "intercom") {
+        await connectIntercom(config, projectId, {});
+      }
+    }
+    return;
+  }
+  const action = await select2({
+    message: "What would you like to do?",
+    choices: [
+      ...SYNCABLE_PLATFORMS.includes(platform2) ? [{ value: "configure", name: "Configure sync settings" }] : [],
+      ...SYNCABLE_PLATFORMS.includes(platform2) ? [{ value: "sync", name: "Trigger manual sync" }] : [],
+      ...platform2 === "jira" || platform2 === "linear" ? [{ value: "configure", name: "Configure settings" }] : [],
+      { value: "disconnect", name: "Disconnect" },
+      { value: "cancel", name: "Cancel" }
+    ]
+  });
+  switch (action) {
+    case "configure":
+      await configureIntegration(config, platform2, projectId);
+      break;
+    case "sync":
+      await syncIntegration(config, platform2, projectId, "");
+      break;
+    case "disconnect":
+      await disconnectIntegration(config, platform2, projectId);
+      break;
+  }
+}
+var integrateCommand = new Command6("integrate").description("Manage integrations (intercom, gong, zendesk, slack, github, jira, linear)").argument("[platform]", "Integration platform").argument("[action]", "Action: status, connect, configure, sync, disconnect").option("--access-key <key>", "Gong access key").option("--access-key-secret <secret>", "Gong access key secret").option("--base-url <url>", "Gong base URL").option("--subdomain <subdomain>", "Zendesk subdomain").option("--email <email>", "Zendesk admin email").option("--api-token <token>", "Zendesk API token").option("--access-token <token>", "Intercom access token").option("--sync-frequency <freq>", "Sync frequency: manual, 1h, 6h, 24h").option("--mode <mode>", "Sync mode: incremental, full").action(async (platformArg, actionArg, opts, cmd) => {
+  const config = requireConfig();
+  const jsonMode = cmd.parent?.opts().json;
+  const projectId = await getProjectId(config);
+  if (!platformArg) {
+    const results = await Promise.all(
+      PLATFORMS.map(async (p) => {
+        const result = await getStatus(config, p, projectId);
+        return {
+          platform: p,
+          name: PLATFORM_LABELS[p],
+          connected: result.ok ? result.data.connected === true : false,
+          data: result.ok ? result.data : null
+        };
+      })
+    );
+    if (jsonMode) {
+      console.log(renderJson(results));
+      return;
+    }
+    console.log(renderMarkdown("# Integrations\n"));
+    for (const r of results) {
+      const status = r.connected ? "\x1B[32mConnected\x1B[0m" : "\x1B[2mNot connected\x1B[0m";
+      console.log(`  ${r.name.padEnd(12)} ${status}`);
+    }
+    console.log("\nRun `hissuno integrate <platform>` to manage a specific integration.");
+    return;
+  }
+  const platform2 = platformArg.toLowerCase();
+  if (!PLATFORMS.includes(platform2)) {
+    error(`Unknown platform "${platformArg}". Supported: ${PLATFORMS.join(", ")}`);
+    process.exit(1);
+  }
+  if (!actionArg) {
+    await interactiveWizard(config, platform2, projectId, jsonMode);
+    return;
+  }
+  const action = actionArg.toLowerCase();
+  switch (action) {
+    case "status": {
+      const result = await getStatus(config, platform2, projectId);
+      if (!result.ok) {
+        const data2 = result.data;
+        error(`Failed: ${data2.error || `HTTP ${result.status}`}`);
+        process.exit(1);
+      }
+      const data = result.data;
+      if (jsonMode) {
+        console.log(renderJson(data));
+      } else {
+        console.log(renderMarkdown(formatStatus(platform2, data)));
+      }
+      break;
+    }
+    case "connect": {
+      const statusResult = await getStatus(config, platform2, projectId);
+      if (statusResult.ok && statusResult.data.connected) {
+        warn(`${PLATFORM_LABELS[platform2]} is already connected.`);
+        return;
+      }
+      if (OAUTH_PLATFORMS.includes(platform2)) {
+        await connectOAuth(config, platform2, projectId);
+      } else if (platform2 === "gong") {
+        await connectGong(config, projectId, {
+          accessKey: opts.accessKey || "",
+          accessKeySecret: opts.accessKeySecret || "",
+          baseUrl: opts.baseUrl || "",
+          syncFrequency: opts.syncFrequency || ""
+        });
+      } else if (platform2 === "zendesk") {
+        await connectZendesk(config, projectId, {
+          subdomain: opts.subdomain || "",
+          email: opts.email || "",
+          apiToken: opts.apiToken || "",
+          syncFrequency: opts.syncFrequency || ""
+        });
+      } else if (platform2 === "intercom") {
+        await connectIntercom(config, projectId, {
+          accessToken: opts.accessToken || "",
+          syncFrequency: opts.syncFrequency || ""
+        });
+      }
+      break;
+    }
+    case "configure": {
+      const statusResult = await getStatus(config, platform2, projectId);
+      if (!statusResult.ok || !statusResult.data.connected) {
+        error(`${PLATFORM_LABELS[platform2]} is not connected. Run 'hissuno integrate ${platform2} connect' first.`);
+        process.exit(1);
+      }
+      await configureIntegration(config, platform2, projectId);
+      break;
+    }
+    case "sync": {
+      const statusResult = await getStatus(config, platform2, projectId);
+      if (!statusResult.ok || !statusResult.data.connected) {
+        error(`${PLATFORM_LABELS[platform2]} is not connected.`);
+        process.exit(1);
+      }
+      await syncIntegration(config, platform2, projectId, opts.mode || "");
+      break;
+    }
+    case "disconnect": {
+      const statusResult = await getStatus(config, platform2, projectId);
+      if (!statusResult.ok || !statusResult.data.connected) {
+        error(`${PLATFORM_LABELS[platform2]} is not connected.`);
+        return;
+      }
+      await disconnectIntegration(config, platform2, projectId);
+      break;
+    }
+    default:
+      error(`Unknown action "${action}". Valid actions: status, connect, configure, sync, disconnect`);
+      process.exit(1);
+  }
+});
+
+// src/commands/update.ts
+import { Command as Command7 } from "commander";
+import { input as input3, select as select3, confirm as confirm3 } from "@inquirer/prompts";
+async function updateScope(existing) {
+  const data = {};
+  const changeName = await confirm3({ message: `Change name? (current: ${existing.name})`, default: false });
+  if (changeName) {
+    data.name = await input3({ message: "New name:", validate: (v) => v.length > 0 || "Required" });
+  }
+  const changeType = await confirm3({ message: `Change type? (current: ${existing.type})`, default: false });
+  if (changeType) {
+    data.type = await select3({
+      message: "New type:",
+      choices: [
+        { value: "product_area", name: "Product Area" },
+        { value: "initiative", name: "Initiative" }
+      ]
+    });
+  }
+  const changeDesc = await confirm3({ message: "Change description?", default: false });
+  if (changeDesc) {
+    data.description = await input3({ message: "New description:" });
+  }
+  const manageGoals = await confirm3({ message: "Manage goals?", default: false });
+  if (manageGoals) {
+    const existingGoals = Array.isArray(existing.goals) ? existing.goals : [];
+    if (existingGoals.length > 0) {
+      console.log(`
+Current goals (${existingGoals.length}):`);
+      for (let i = 0; i < existingGoals.length; i++) {
+        console.log(`  ${i + 1}. ${existingGoals[i].text}`);
+      }
+      console.log("");
+    }
+    const goalAction = await select3({
+      message: "Goal action:",
+      choices: [
+        { value: "add", name: "Add new goals" },
+        { value: "replace", name: "Replace all goals" },
+        { value: "clear", name: "Clear all goals" },
+        { value: "skip", name: "Keep current goals" }
+      ]
+    });
+    if (goalAction === "clear") {
+      data.goals = null;
+    } else if (goalAction === "replace") {
+      const goals = [];
+      console.log("Enter new goals (empty text to finish).\n");
+      while (goals.length < 10) {
+        const text = await input3({ message: `Goal ${goals.length + 1} (empty to finish):` });
+        if (!text) break;
+        goals.push({ id: `g_${Date.now()}_${goals.length}`, text });
+      }
+      data.goals = goals.length > 0 ? goals : null;
+    } else if (goalAction === "add") {
+      const goals = [...existingGoals];
+      console.log("Enter additional goals (empty text to finish).\n");
+      while (goals.length < 10) {
+        const text = await input3({ message: `Goal ${goals.length + 1} (empty to finish):` });
+        if (!text) break;
+        goals.push({ id: `g_${Date.now()}_${goals.length}`, text });
+      }
+      data.goals = goals;
+    }
+  }
+  return data;
+}
+var TYPE_ENDPOINTS4 = {
+  scopes: {
+    getPath: (id) => `/api/product-scopes/${id}`,
+    patchPath: (id) => `/api/product-scopes/${id}`,
+    key: "scope"
+  }
+};
+var updateCommand = new Command7("update").description("Update an existing resource").argument("<type>", "Resource type: scopes").argument("<id>", "Resource ID").action(async (type, id, _opts, cmd) => {
+  const config = requireConfig();
+  const jsonMode = cmd.parent?.opts().json;
+  const supportedTypes = Object.keys(TYPE_ENDPOINTS4);
+  if (!supportedTypes.includes(type)) {
+    error(`Invalid type "${type}". Updatable types: ${supportedTypes.join(", ")}`);
+    process.exit(1);
+  }
+  const projectId = await resolveProjectId(config);
+  const endpoint = TYPE_ENDPOINTS4[type];
+  const getResult = await apiCall(
+    config,
+    "GET",
+    buildPath(endpoint.getPath(id), { projectId })
+  );
+  if (!getResult.ok) {
+    const data = getResult.data;
+    error(`Failed to fetch ${type}: ${data.error || `HTTP ${getResult.status}`}`);
+    process.exit(1);
+  }
+  const existing = getResult.data[endpoint.key] ?? getResult.data;
+  let updates;
+  switch (type) {
+    case "scopes":
+      updates = await updateScope(existing);
+      break;
+    default:
+      error(`Unsupported type: ${type}`);
+      process.exit(1);
+  }
+  if (Object.keys(updates).length === 0) {
+    console.log("No changes made.");
+    return;
+  }
+  try {
+    const result = await apiCall(
+      config,
+      "PATCH",
+      buildPath(endpoint.patchPath(id), { projectId }),
+      updates
+    );
+    if (!result.ok) {
+      const errData = result.data;
+      error(`Failed: ${errData.error || `HTTP ${result.status}`}`);
+      process.exit(1);
+    }
+    if (jsonMode) {
+      console.log(renderJson(result.data));
+    } else {
+      success("\nUpdated successfully!");
+    }
+  } catch (err) {
+    error(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/setup.ts
+import fs4 from "fs";
+import path6 from "path";
+import { Command as Command8 } from "commander";
+
+// src/lib/log.ts
+var BOLD2 = "\x1B[1m";
+var DIM2 = "\x1B[2m";
+var RESET2 = "\x1B[0m";
+var CYAN2 = "\x1B[36m";
+var RED2 = "\x1B[31m";
+var YELLOW2 = "\x1B[33m";
+var GREEN2 = "\x1B[32m";
+var log = {
+  banner() {
+    console.log();
+    console.log(`  ${BOLD2}${CYAN2}Hissuno Setup${RESET2}`);
+    console.log(`  ${DIM2}Unified context layer for product agents${RESET2}`);
+    console.log();
+  },
+  step(msg) {
+    process.stdout.write(`  ${CYAN2}>${RESET2} ${msg}... `);
+  },
+  success(msg) {
+    console.log(`  ${GREEN2}\u2713${RESET2} ${msg}`);
+  },
+  info(msg) {
+    console.log(`  ${CYAN2}i${RESET2} ${msg}`);
+  },
+  warn(msg) {
+    console.log(`  ${YELLOW2}!${RESET2} ${msg}`);
+  },
+  error(msg) {
+    console.log(`  ${RED2}\u2717${RESET2} ${msg}`);
+  },
+  fatal(msg) {
+    console.log();
+    console.log(`  ${BOLD2}${RED2}Error: ${msg}${RESET2}`);
+    console.log(`  ${DIM2}Run with --help for usage information${RESET2}`);
+    console.log();
+  },
+  ready(seeded) {
+    console.log();
+    console.log(`  ${BOLD2}${GREEN2}Setup complete! Starting Hissuno...${RESET2}`);
+    console.log();
+    if (seeded) {
+      console.log(`  ${DIM2}Demo account:${RESET2}`);
+      console.log(`    Email:    admin@hissuno.com`);
+      console.log(`    Password: admin123`);
+      console.log();
+    }
+    console.log(`  ${DIM2}Open http://localhost:3000${RESET2}`);
+    console.log();
+    this._integrationHint();
+  },
+  nextSteps(seeded) {
+    console.log();
+    console.log(`  ${BOLD2}${GREEN2}Setup complete!${RESET2}`);
+    console.log();
+    console.log(`  ${BOLD2}Next steps:${RESET2}`);
+    console.log();
+    console.log(`    cd hissuno/app`);
+    console.log(`    npm run dev`);
+    console.log();
+    if (seeded) {
+      console.log(`  ${DIM2}Demo account:${RESET2}`);
+      console.log(`    Email:    admin@hissuno.com`);
+      console.log(`    Password: admin123`);
+      console.log();
+    }
+    console.log(`  ${DIM2}Then open http://localhost:3000${RESET2}`);
+    console.log();
+    this._integrationHint();
+  },
+  _integrationHint() {
+    console.log(`  ${BOLD2}Connect your data sources:${RESET2}`);
+    console.log(`    ${CYAN2}hissuno integrate${RESET2}          ${DIM2}# see all integrations${RESET2}`);
+    console.log(`    ${CYAN2}hissuno integrate slack${RESET2}    ${DIM2}# connect Slack${RESET2}`);
+    console.log(`    ${CYAN2}hissuno integrate intercom${RESET2} ${DIM2}# connect Intercom${RESET2}`);
+    console.log();
+  }
+};
+
+// src/lib/exec.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function exec2(cmd, args, opts) {
+  const { stdout, stderr } = await execFileAsync(cmd, args, {
+    cwd: opts?.cwd,
+    env: { ...process.env, ...opts?.env }
+  });
+  return { stdout: stdout.toString(), stderr: stderr.toString() };
+}
+function execStream(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd: opts?.cwd,
+      env: { ...process.env, ...opts?.env },
+      stdio: "inherit"
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+function execCapture(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd: opts?.cwd,
+      env: { ...process.env, ...opts?.env },
+      stdio: ["inherit", "pipe", "inherit"]
+    });
+    let stdout = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve({ stdout });
+      else reject(new Error(`${cmd} exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+async function commandExists(cmd) {
+  try {
+    await execFileAsync("which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/setup/check-node.ts
+async function checkNode() {
+  const major = parseInt(process.versions.node.split(".")[0], 10);
+  if (major < 20) {
+    throw new Error(`Node.js 20+ required. You have v${process.versions.node}`);
+  }
+  log.success(`Node.js v${process.versions.node}`);
+  const hasGit = await commandExists("git");
+  if (!hasGit) {
+    throw new Error("git is required but not found on PATH");
+  }
+  log.success("git found");
+}
+
+// src/commands/setup/clone.ts
+import fs from "fs";
+import path from "path";
+async function cloneRepo() {
+  const projectDir = path.resolve("hissuno");
+  if (fs.existsSync(projectDir)) {
+    throw new Error('Directory "hissuno" already exists');
+  }
+  log.info("Cloning Hissuno...");
+  await execStream("git", [
+    "clone",
+    "--depth",
+    "1",
+    "https://github.com/hissuno/hissuno.git",
+    projectDir
+  ]);
+  fs.rmSync(path.join(projectDir, ".git"), { recursive: true, force: true });
+  log.success("Repository cloned");
+  return projectDir;
+}
+
+// src/commands/setup/install.ts
+async function installDeps(appDir) {
+  log.info("Installing dependencies...");
+  await execStream("npm", ["install"], { cwd: appDir });
+  log.success("Dependencies installed");
+}
+async function buildWidget(appDir) {
+  log.info("Building feedback widget...");
+  await execStream("npm", ["run", "build:widget"], { cwd: appDir });
+  log.success("Widget built");
+}
+
+// src/commands/setup/detect-postgres.ts
+import { select as select4, input as input4 } from "@inquirer/prompts";
+async function detectPostgres() {
+  const hasPsql = await commandExists("psql");
+  if (hasPsql) {
+    return handleExistingPostgres();
+  }
+  return handleMissingPostgres();
+}
+async function handleExistingPostgres() {
+  log.success("PostgreSQL found");
+  const choice = await select4({
+    message: "How would you like to connect to PostgreSQL?",
+    choices: [
+      { name: "Use local PostgreSQL (default)", value: "local" },
+      { name: "Enter DATABASE_URL manually", value: "manual" }
+    ]
+  });
+  if (choice === "manual") {
+    return promptManualUrl();
+  }
+  const databaseUrl = await input4({
+    message: "DATABASE_URL:",
+    default: "postgresql://localhost:5432/hissuno"
+  });
+  return { databaseUrl, needsCreateDb: true, isDocker: false };
+}
+async function handleMissingPostgres() {
+  log.warn("PostgreSQL not found on PATH");
+  const choices = [];
+  const hasBrew = await commandExists("brew");
+  const hasApt = await commandExists("apt-get");
+  const hasDocker = await commandExists("docker");
+  if (hasBrew) {
+    choices.push({ name: "Install via Homebrew (macOS)", value: "brew" });
+  }
+  if (hasApt) {
+    choices.push({ name: "Install via apt-get (Linux)", value: "apt" });
+  }
+  if (hasDocker) {
+    choices.push({ name: "Run via Docker", value: "docker" });
+  }
+  choices.push({ name: "Enter DATABASE_URL manually", value: "manual" });
+  const choice = await select4({
+    message: "How would you like to set up PostgreSQL?",
+    choices
+  });
+  switch (choice) {
+    case "brew":
+      return installViaBrew();
+    case "apt":
+      return installViaApt();
+    case "docker":
+      return installViaDocker();
+    default:
+      return promptManualUrl();
+  }
+}
+async function installViaBrew() {
+  log.info("Installing PostgreSQL via Homebrew...");
+  await execStream("brew", ["install", "postgresql@15"]);
+  await execStream("brew", ["install", "pgvector"]);
+  await execStream("brew", ["services", "start", "postgresql@15"]);
+  log.success("PostgreSQL installed and started");
+  const databaseUrl = await input4({
+    message: "DATABASE_URL:",
+    default: "postgresql://localhost:5432/hissuno"
+  });
+  return { databaseUrl, needsCreateDb: true, isDocker: false };
+}
+async function installViaApt() {
+  log.info("Installing PostgreSQL via apt-get...");
+  await execStream("sudo", ["apt-get", "install", "-y", "postgresql-15", "postgresql-15-pgvector"]);
+  log.success("PostgreSQL installed");
+  const databaseUrl = await input4({
+    message: "DATABASE_URL:",
+    default: "postgresql://localhost:5432/hissuno"
+  });
+  return { databaseUrl, needsCreateDb: true, isDocker: false };
+}
+async function installViaDocker() {
+  log.info("Starting PostgreSQL via Docker...");
+  try {
+    const { stdout } = await exec2("docker", ["ps", "-a", "--filter", "name=hissuno-postgres", "--format", "{{.Names}}"]);
+    if (stdout.trim() === "hissuno-postgres") {
+      log.info('Container "hissuno-postgres" already exists, starting it...');
+      await execStream("docker", ["start", "hissuno-postgres"]);
+    } else {
+      await execStream("docker", [
+        "run",
+        "-d",
+        "--name",
+        "hissuno-postgres",
+        "-e",
+        "POSTGRES_USER=hissuno",
+        "-e",
+        "POSTGRES_PASSWORD=hissuno",
+        "-e",
+        "POSTGRES_DB=hissuno",
+        "-p",
+        "5432:5432",
+        "pgvector/pgvector:pg16"
+      ]);
+    }
+  } catch {
+    await execStream("docker", [
+      "run",
+      "-d",
+      "--name",
+      "hissuno-postgres",
+      "-e",
+      "POSTGRES_USER=hissuno",
+      "-e",
+      "POSTGRES_PASSWORD=hissuno",
+      "-e",
+      "POSTGRES_DB=hissuno",
+      "-p",
+      "5432:5432",
+      "pgvector/pgvector:pg16"
+    ]);
+  }
+  log.success("PostgreSQL running in Docker");
+  return {
+    databaseUrl: "postgresql://hissuno:hissuno@localhost:5432/hissuno",
+    needsCreateDb: false,
+    isDocker: true
+  };
+}
+async function promptManualUrl() {
+  const databaseUrl = await input4({
+    message: "Enter your DATABASE_URL:",
+    validate: (val) => {
+      if (!val.startsWith("postgresql://") && !val.startsWith("postgres://")) {
+        return "URL must start with postgresql:// or postgres://";
+      }
+      return true;
+    }
+  });
+  return { databaseUrl, needsCreateDb: false, isDocker: false };
+}
+
+// src/commands/setup/configure-env.ts
+import fs2 from "fs";
+import path2 from "path";
+import crypto from "crypto";
+import { confirm as confirm4, input as input5, password as password2 } from "@inquirer/prompts";
+async function configureEnv(appDir, databaseUrl, envFile = ".env.local") {
+  const appUrl = await input5({
+    message: "App URL:",
+    default: "http://localhost:3000"
+  });
+  const wantsOpenai = await confirm4({
+    message: "Add an OpenAI API key? (enables AI analysis & semantic search)",
+    default: true
+  });
+  let openaiKey;
+  if (wantsOpenai) {
+    openaiKey = await password2({
+      message: "Enter your OpenAI API key:",
+      mask: "*",
+      validate: (val) => {
+        if (!val.startsWith("sk-")) {
+          return "API key should start with sk-";
+        }
+        return true;
+      }
+    });
+  }
+  const authSecret = crypto.randomBytes(32).toString("base64");
+  const envLines = [
+    `DATABASE_URL=${databaseUrl}`,
+    `AUTH_SECRET=${authSecret}`,
+    `NEXT_PUBLIC_APP_URL=${appUrl}`
+  ];
+  if (openaiKey) {
+    envLines.push(`OPENAI_API_KEY=${openaiKey}`);
+  }
+  envLines.push("");
+  const envContent = envLines.join("\n");
+  const envPath = path2.join(appDir, envFile);
+  fs2.writeFileSync(envPath, envContent, "utf-8");
+  log.success(`${envFile} created`);
+  return { appUrl };
+}
+
+// src/commands/setup/setup-database.ts
+import path3 from "path";
+async function setupDatabase(appDir, opts) {
+  const { databaseUrl, needsCreateDb = false, isDocker = false } = opts;
+  if (needsCreateDb) {
+    const dbName = extractDbName(databaseUrl);
+    log.info(`Creating database "${dbName}"...`);
+    try {
+      await exec2("createdb", [dbName]);
+      log.success(`Database "${dbName}" created`);
+    } catch (err) {
+      if (err.stderr?.includes("already exists")) {
+        log.info(`Database "${dbName}" already exists`);
+      } else {
+        throw err;
+      }
+    }
+  }
+  log.info("Enabling pgvector extension...");
+  if (isDocker) {
+    await exec2("docker", [
+      "exec",
+      "hissuno-postgres",
+      "psql",
+      "-U",
+      "hissuno",
+      "-d",
+      "hissuno",
+      "-c",
+      "CREATE EXTENSION IF NOT EXISTS vector;"
+    ]);
+  } else {
+    await exec2("psql", [databaseUrl, "-c", "CREATE EXTENSION IF NOT EXISTS vector;"]);
+  }
+  let hasVector = false;
+  try {
+    let stdout;
+    if (isDocker) {
+      const result = await exec2("docker", [
+        "exec",
+        "hissuno-postgres",
+        "psql",
+        "-U",
+        "hissuno",
+        "-d",
+        "hissuno",
+        "-tAc",
+        "SELECT 1 FROM pg_extension WHERE extname = 'vector';"
+      ]);
+      stdout = result.stdout;
+    } else {
+      const result = await exec2("psql", [
+        databaseUrl,
+        "-tAc",
+        "SELECT 1 FROM pg_extension WHERE extname = 'vector';"
+      ]);
+      stdout = result.stdout;
+    }
+    hasVector = stdout.trim() === "1";
+  } catch {
+  }
+  if (!hasVector) {
+    throw new Error(
+      "pgvector extension could not be enabled. Install pgvector for your PostgreSQL version: https://github.com/pgvector/pgvector#installation"
+    );
+  }
+  log.success("pgvector enabled");
+  log.info("Pushing database schema...");
+  const drizzleKit = path3.join(appDir, "node_modules", ".bin", "drizzle-kit");
+  await execStream(drizzleKit, ["push"], {
+    cwd: appDir,
+    env: { DATABASE_URL: databaseUrl }
+  });
+  log.success("Database schema pushed");
+}
+function extractDbName(url) {
+  const parsed = new URL(url);
+  return parsed.pathname.slice(1);
+}
+
+// src/commands/setup/seed.ts
+import path4 from "path";
+import { confirm as confirm5 } from "@inquirer/prompts";
+async function seedDatabase(appDir, envFile = ".env.local") {
+  const shouldSeed = await confirm5({
+    message: "Seed with demo data? (admin user + project with sample sessions, issues, companies, and contacts)",
+    default: true
+  });
+  if (!shouldSeed) {
+    log.info("Skipping seed");
+    return { seeded: false };
+  }
+  try {
+    log.info("Seeding database...");
+    const tsx = path4.join(appDir, "node_modules", ".bin", "tsx");
+    const { stdout } = await execCapture(
+      tsx,
+      ["--tsconfig", "tsconfig.json", "--env-file", envFile, "src/scripts/seed.ts", "--demo", "--output-api-key"],
+      { cwd: appDir }
+    );
+    log.success("Demo data seeded");
+    const passwordMatch = stdout.match(/\[seed\] Generated admin password: (\S+)/);
+    if (passwordMatch) {
+      log.info(`Admin email: admin@hissuno.com`);
+      log.info(`Admin password: ${passwordMatch[1]}`);
+    }
+    const projectMatch = stdout.match(/\[seed\] Created demo project: (.+) \((.+)\)/);
+    if (projectMatch) {
+      log.info(`Demo project: ${projectMatch[1]} (${projectMatch[2]})`);
+    }
+    const apiKeyMatch = stdout.match(/HISSUNO_API_KEY=(\S+)/);
+    return { seeded: true, apiKey: apiKeyMatch?.[1] };
+  } catch (err) {
+    log.warn(`Seed failed: ${err.message}`);
+    log.warn("You can run it manually later: npm run seed");
+    return { seeded: false };
+  }
+}
+
+// src/commands/setup/create-config.ts
+import { confirm as confirm6 } from "@inquirer/prompts";
+async function createConfig(apiKey, baseUrl = "http://localhost:3000") {
+  const shouldConfigure = await confirm6({
+    message: "Auto-configure the CLI with the generated API key?",
+    default: true
+  });
+  if (!shouldConfigure) {
+    log.info("Skipping auto-config. Run `hissuno config` later to connect manually.");
+    return;
+  }
+  saveConfig({
+    api_key: apiKey,
+    base_url: baseUrl
+  });
+  log.success("CLI configured (~/.hissuno/config.json)");
+  log.info("Run `hissuno status` to verify your connection.");
+}
+
+// src/commands/setup/start.ts
+import { confirm as confirm7 } from "@inquirer/prompts";
+async function startServer(appDir, seeded) {
+  const shouldStart = await confirm7({
+    message: "Start Hissuno now?",
+    default: true
+  });
+  if (!shouldStart) {
+    log.nextSteps(seeded);
+    return;
+  }
+  log.ready(seeded);
+  await execStream("npm", ["run", "dev"], { cwd: appDir });
+}
+
+// src/commands/setup/setup-oauth.ts
+import fs3 from "fs";
+import path5 from "path";
+import { input as input6, password as password3, select as select5 } from "@inquirer/prompts";
+var OAUTH_PLATFORMS2 = {
+  slack: {
+    label: "Slack",
+    envVars: [
+      { key: "SLACK_CLIENT_ID", prompt: "Slack Client ID:", mask: false },
+      { key: "SLACK_CLIENT_SECRET", prompt: "Slack Client Secret:", mask: true }
+    ]
+  },
+  github: {
+    label: "GitHub",
+    envVars: [
+      { key: "GITHUB_APP_SLUG", prompt: "GitHub App slug:", mask: false },
+      { key: "GITHUB_APP_ID", prompt: "GitHub App ID:", mask: false },
+      { key: "GITHUB_APP_PRIVATE_KEY", prompt: "GitHub Private Key (base64-encoded):", mask: true }
+    ]
+  },
+  jira: {
+    label: "Jira",
+    envVars: [
+      { key: "JIRA_CLIENT_ID", prompt: "Jira Client ID:", mask: false },
+      { key: "JIRA_CLIENT_SECRET", prompt: "Jira Client Secret:", mask: true }
+    ]
+  },
+  linear: {
+    label: "Linear",
+    envVars: [
+      { key: "LINEAR_CLIENT_ID", prompt: "Linear Client ID:", mask: false },
+      { key: "LINEAR_CLIENT_SECRET", prompt: "Linear Client Secret:", mask: true }
+    ]
+  },
+  intercom: {
+    label: "Intercom",
+    envVars: [
+      { key: "INTERCOM_CLIENT_ID", prompt: "Intercom Client ID:", mask: false },
+      { key: "INTERCOM_CLIENT_SECRET", prompt: "Intercom Client Secret:", mask: true }
+    ]
+  }
+};
+var OAUTH_PLATFORM_NAMES = Object.keys(OAUTH_PLATFORMS2);
+async function setupOAuth(appDir, platformArg, opts = {}) {
+  const platform2 = platformArg ? validatePlatform(platformArg) : await select5({
+    message: "Which integration?",
+    choices: OAUTH_PLATFORM_NAMES.map((p) => ({
+      value: p,
+      name: OAUTH_PLATFORMS2[p].label
+    }))
+  });
+  const config = OAUTH_PLATFORMS2[platform2];
+  const values = {};
+  for (const envVar of config.envVars) {
+    const flagValue = resolveFlag(envVar.key, opts);
+    if (flagValue) {
+      values[envVar.key] = flagValue;
+    } else if (envVar.mask) {
+      values[envVar.key] = await password3({
+        message: envVar.prompt,
+        mask: "*",
+        validate: (v) => v.length > 0 || "Required"
+      });
+    } else {
+      values[envVar.key] = await input6({
+        message: envVar.prompt,
+        validate: (v) => v.length > 0 || "Required"
+      });
+    }
+  }
+  const envPath = path5.join(appDir, ".env.local");
+  if (!fs3.existsSync(envPath)) {
+    throw new Error(`.env.local not found at ${envPath}. Run 'hissuno setup' first.`);
+  }
+  const existing = fs3.readFileSync(envPath, "utf-8");
+  const newLines = [];
+  for (const [key, value] of Object.entries(values)) {
+    if (existing.includes(`${key}=`)) {
+      log.warn(`${key} already set in .env.local - skipping`);
+    } else {
+      newLines.push(`${key}=${value}`);
+    }
+  }
+  if (newLines.length > 0) {
+    const suffix = (existing.endsWith("\n") ? "" : "\n") + newLines.join("\n") + "\n";
+    fs3.appendFileSync(envPath, suffix);
+    log.success(`${config.label} OAuth credentials added to .env.local`);
+  } else {
+    log.info(`${config.label} credentials already present - no changes made`);
+  }
+  log.info("Restart the server for changes to take effect:");
+  console.log(`    npm run dev`);
+  console.log();
+}
+function validatePlatform(name) {
+  const lower = name.toLowerCase();
+  if (!OAUTH_PLATFORM_NAMES.includes(lower)) {
+    throw new Error(
+      `Unknown OAuth platform "${name}". Supported: ${OAUTH_PLATFORM_NAMES.join(", ")}`
+    );
+  }
+  return lower;
+}
+function resolveFlag(envKey, opts) {
+  switch (envKey) {
+    case "SLACK_CLIENT_ID":
+    case "JIRA_CLIENT_ID":
+    case "LINEAR_CLIENT_ID":
+    case "INTERCOM_CLIENT_ID":
+      return opts.clientId;
+    case "SLACK_CLIENT_SECRET":
+    case "JIRA_CLIENT_SECRET":
+    case "LINEAR_CLIENT_SECRET":
+    case "INTERCOM_CLIENT_SECRET":
+      return opts.clientSecret;
+    case "GITHUB_APP_SLUG":
+      return opts.appSlug;
+    case "GITHUB_APP_ID":
+      return opts.appId;
+    case "GITHUB_APP_PRIVATE_KEY":
+      return opts.privateKey;
+    default:
+      return void 0;
+  }
+}
+
+// src/commands/setup.ts
+var STEP_NAMES = [
+  "check-node",
+  "clone",
+  "install",
+  "build",
+  "postgres",
+  "env",
+  "database",
+  "seed",
+  "config",
+  "start"
+];
+function resolveAppDir() {
+  return path6.join(path6.resolve("hissuno"), "app");
+}
+function resolveDatabaseUrl(appDir, envFile) {
+  if (process.env.DATABASE_URL) return process.env.DATABASE_URL;
+  const envPath = path6.join(appDir, envFile);
+  try {
+    const content = fs4.readFileSync(envPath, "utf-8");
+    const match = content.match(/^DATABASE_URL=(.+)$/m);
+    if (match) return match[1].trim();
+  } catch {
+  }
+  return void 0;
+}
+function shouldRun(step, from, only) {
+  if (only) return only.has(step);
+  if (!from) return true;
+  return STEP_NAMES.indexOf(step) >= STEP_NAMES.indexOf(from);
+}
+function parseSteps(raw) {
+  const steps = /* @__PURE__ */ new Set();
+  for (const s of raw.split(",")) {
+    const trimmed = s.trim();
+    if (!STEP_NAMES.includes(trimmed)) {
+      throw new Error(`Unknown step "${trimmed}". Valid steps: ${STEP_NAMES.join(", ")}`);
+    }
+    steps.add(trimmed);
+  }
+  return steps;
+}
+var setupCommand = new Command8("setup").description("Set up a new Hissuno instance (clone, install, configure)").option("--from <step>", `Resume from a step: ${STEP_NAMES.join(", ")}`).option("--only <steps>", "Run only specific steps (comma-separated)").option("--app-dir <dir>", "Path to the app directory (default: ./hissuno/app)").option("--env <environment>", "Target environment (determines env file: .env.<environment>)");
+setupCommand.command("oauth").argument("[platform]", `Integration: ${OAUTH_PLATFORM_NAMES.join(", ")}`).description("Configure OAuth credentials for an integration").option("--client-id <id>", "OAuth client ID").option("--client-secret <secret>", "OAuth client secret").option("--app-slug <slug>", "GitHub App slug").option("--app-id <id>", "GitHub App ID").option("--private-key <key>", "GitHub private key (base64)").option("--app-dir <dir>", "Path to the app directory (default: ./hissuno/app)").action(async (platformArg, opts) => {
+  log.banner();
+  try {
+    const appDir = opts.appDir || resolveAppDir();
+    await setupOAuth(appDir, platformArg, {
+      clientId: opts.clientId,
+      clientSecret: opts.clientSecret,
+      appSlug: opts.appSlug,
+      appId: opts.appId,
+      privateKey: opts.privateKey
+    });
+  } catch (err) {
+    log.fatal(err.message);
+    process.exit(1);
+  }
+});
+setupCommand.action(async (opts) => {
+  log.banner();
+  const from = opts.from;
+  const only = opts.only ? parseSteps(opts.only) : void 0;
+  if (from && !STEP_NAMES.includes(from)) {
+    log.fatal(`Unknown step "${from}". Valid steps: ${STEP_NAMES.join(", ")}`);
+    process.exit(1);
+  }
+  const run = (step) => shouldRun(step, from, only);
+  try {
+    let appDir = opts.appDir ? path6.resolve(opts.appDir) : path6.join(path6.resolve("hissuno"), "app");
+    let projectDir = path6.dirname(appDir);
+    const envFile = opts.env ? `.env.${opts.env}` : ".env.local";
+    let databaseUrl = "";
+    let appUrl = "http://localhost:3000";
+    let seeded = false;
+    let apiKey;
+    if (run("check-node")) {
+      await checkNode();
+    }
+    if (run("clone")) {
+      projectDir = await cloneRepo();
+      appDir = path6.join(projectDir, "app");
+    }
+    if (run("install")) {
+      await installDeps(appDir);
+    }
+    if (run("build")) {
+      await buildWidget(appDir);
+    }
+    if (run("postgres")) {
+      const pgResult = await detectPostgres();
+      databaseUrl = pgResult.databaseUrl;
+      if (run("env")) {
+        const envResult = await configureEnv(appDir, databaseUrl, envFile);
+        appUrl = envResult.appUrl;
+      }
+      if (run("database")) {
+        await setupDatabase(appDir, pgResult);
+      }
+    } else {
+      if (run("env")) {
+        const url = process.env.DATABASE_URL || "postgresql://localhost:5432/hissuno";
+        const envResult = await configureEnv(appDir, url, envFile);
+        appUrl = envResult.appUrl;
+      }
+      if (run("database")) {
+        const url = resolveDatabaseUrl(appDir, envFile);
+        if (!url) {
+          throw new Error(
+            "No DATABASE_URL found. Either run the postgres step first, set DATABASE_URL in your environment, or configure it in " + envFile
+          );
+        }
+        databaseUrl = url;
+        await setupDatabase(appDir, { databaseUrl });
+      }
+    }
+    if (run("seed")) {
+      const seedResult = await seedDatabase(appDir, envFile);
+      seeded = seedResult.seeded;
+      apiKey = seedResult.apiKey;
+    }
+    if (run("config") && apiKey) {
+      await createConfig(apiKey, appUrl);
+    }
+    if (run("start")) {
+      await startServer(appDir, seeded);
+    }
+  } catch (err) {
+    log.fatal(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command9 } from "commander";
+import { input as input7, password as password4, confirm as confirm8, select as select6 } from "@inquirer/prompts";
+var BOLD3 = "\x1B[1m";
+var DIM3 = "\x1B[2m";
+var RESET3 = "\x1B[0m";
+var CYAN3 = "\x1B[36m";
+async function runConfigWizard() {
+  console.log(`
+${BOLD3}Step 1: Authentication${RESET3}`);
+  const apiKey = await password4({
+    message: "API key (hiss_...):",
+    mask: "*",
+    validate: (val) => {
+      if (!val.startsWith("hiss_")) return "API key must start with hiss_";
+      if (val.length < 10) return "API key is too short";
+      return true;
+    }
+  });
+  const baseUrl = await input7({
+    message: "Hissuno URL:",
+    default: "http://localhost:3000",
+    validate: (val) => {
+      try {
+        new URL(val);
+        return true;
+      } catch {
+        return "Must be a valid URL";
+      }
+    }
+  });
+  const normalizedUrl = baseUrl.replace(/\/+$/, "");
+  const config = { api_key: apiKey, base_url: normalizedUrl };
+  process.stdout.write("Validating... ");
+  try {
+    const result = await apiCall(config, "GET", "/api/projects");
+    const projects = Array.isArray(result.data) ? result.data : result.data?.projects;
+    if (!result.ok || !Array.isArray(projects) || projects.length === 0) {
+      const data = result.data;
+      console.log("");
+      error(`Validation failed: ${data.error || `HTTP ${result.status}`}`);
+      process.exit(1);
+    }
+    const projectName = projects[0].name;
+    const projectId = projects[0].id;
+    success("Authenticated.");
+    console.log(`
+${BOLD3}Step 2: Project${RESET3}`);
+    console.log(`Using project: ${BOLD3}${projectName}${RESET3} (${DIM3}${projectId}${RESET3})`);
+    config.project_id = projectId;
+    return config;
+  } catch (err) {
+    console.log("");
+    error(`Connection failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    process.exit(1);
+  }
+}
+var configCommand = new Command9("config").description("Configure CLI connection (API key, URL, project)").action(async () => {
+  console.log(`
+${BOLD3}${CYAN3}Hissuno Config${RESET3}`);
+  console.log(`${DIM3}Connect the CLI to your Hissuno instance.${RESET3}
+`);
+  const existing = loadConfig();
+  if (existing) {
+    const reconfigure = await confirm8({
+      message: "Existing configuration found. Reconfigure?",
+      default: false
+    });
+    if (!reconfigure) {
+      console.log("Keeping existing configuration.");
+      return;
+    }
+  }
+  const fullConfig = await runConfigWizard();
+  saveConfig(fullConfig);
+  success("Configuration saved to ~/.hissuno/config.json");
+  console.log(`
+${BOLD3}Step 3: Connect Data Sources (optional)${RESET3}`);
+  let connectMore = await confirm8({
+    message: "Would you like to connect a data source?",
+    default: true
+  });
+  while (connectMore) {
+    const platform2 = await select6({
+      message: "Select a platform:",
+      choices: PLATFORMS.map((p) => ({
+        value: p,
+        name: PLATFORM_LABELS[p]
+      }))
+    });
+    if (OAUTH_PLATFORMS.includes(platform2)) {
+      await connectOAuth(fullConfig, platform2, fullConfig.project_id);
+    } else if (platform2 === "gong") {
+      await connectGong(fullConfig, fullConfig.project_id, {});
+    } else if (platform2 === "zendesk") {
+      await connectZendesk(fullConfig, fullConfig.project_id, {});
+    } else if (platform2 === "intercom") {
+      await connectIntercom(fullConfig, fullConfig.project_id, {});
+    }
+    connectMore = await confirm8({
+      message: "Connect another?",
+      default: false
+    });
+  }
+  console.log("");
+  success("Configuration complete!");
+  console.log(`
+${DIM3}Next steps:${RESET3}
+  hissuno status                   Check connection health
+  hissuno search "checkout bugs"   Search your intelligence
+  hissuno list feedback            List feedback sessions
+  hissuno integrate                Manage integrations
+`);
+});
+function maskApiKey(key) {
+  if (key.length <= 8) return key;
+  return key.slice(0, 8) + "*".repeat(12);
+}
+configCommand.command("show").description("Display current configuration").action(async (_, cmd) => {
+  const json = cmd.parent?.parent?.opts().json;
+  const config = loadConfig();
+  if (!config) {
+    if (json) {
+      console.log(renderJson({ error: "Not configured" }));
+    } else {
+      console.log("Not configured. Run `hissuno config` to set up.");
+    }
+    return;
+  }
+  const profileName = getActiveProfileName();
+  if (json) {
+    console.log(renderJson({
+      profile: profileName,
+      api_key: maskApiKey(config.api_key),
+      base_url: config.base_url,
+      project_id: config.project_id ?? null
+    }));
+    return;
+  }
+  console.log(`
+  ${BOLD3}${CYAN3}Hissuno Configuration${RESET3}
+`);
+  console.log(`  ${DIM3}Profile:${RESET3}  ${profileName}`);
+  console.log(`  ${DIM3}API Key:${RESET3}  ${maskApiKey(config.api_key)}`);
+  console.log(`  ${DIM3}URL:${RESET3}      ${config.base_url}`);
+  if (config.project_id) {
+    console.log(`  ${DIM3}Project:${RESET3}  ${config.project_id}`);
+  }
+  console.log();
+});
+
+// src/commands/profile.ts
+import { Command as Command10 } from "commander";
+function getJson(cmd) {
+  return cmd.parent?.parent?.opts().json ?? false;
+}
+var profileCommand = new Command10("profile").description("Manage configuration profiles");
+profileCommand.command("list").description("List all profiles").action((_, cmd) => {
+  const json = getJson(cmd);
+  const full = migrateToMultiProfile();
+  const names = Object.keys(full.profiles);
+  if (json) {
+    console.log(renderJson({
+      active: full.active_profile,
+      profiles: names
+    }));
+    return;
+  }
+  console.log(`
+  ${BOLD}${CYAN}Profiles${RESET}
+`);
+  if (names.length === 0) {
+    console.log(`  ${DIM}No profiles configured. Run \`hissuno profile create <name>\` to create one.${RESET}
+`);
+    return;
+  }
+  for (const name of names) {
+    const marker = name === full.active_profile ? `${GREEN}* ${RESET}` : "  ";
+    const profile = full.profiles[name];
+    const url = profile.base_url ? `${DIM}${profile.base_url}${RESET}` : "";
+    console.log(`  ${marker}${BOLD}${name}${RESET}  ${url}`);
+  }
+  console.log();
+});
+profileCommand.command("use <name>").description("Switch active profile").action((name, _, cmd) => {
+  const json = getJson(cmd);
+  migrateToMultiProfile();
+  try {
+    setActiveProfile(name);
+  } catch (err) {
+    if (json) {
+      console.log(renderJson({ error: err.message }));
+    } else {
+      error(err.message);
+    }
+    process.exit(1);
+  }
+  if (json) {
+    console.log(renderJson({ active: name }));
+  } else {
+    success(`Switched to profile "${name}".`);
+  }
+});
+profileCommand.command("create <name>").description("Create a new profile via config wizard").action(async (name, _, cmd) => {
+  const json = getJson(cmd);
+  migrateToMultiProfile();
+  console.log(`
+${BOLD}${CYAN}Create Profile: ${name}${RESET}`);
+  console.log(`${DIM}Configure connection for this profile.${RESET}
+`);
+  const config = await runConfigWizard();
+  try {
+    createProfile(name, config);
+  } catch (err) {
+    if (json) {
+      console.log(renderJson({ error: err.message }));
+    } else {
+      error(err.message);
+    }
+    process.exit(1);
+  }
+  if (json) {
+    console.log(renderJson({ created: name }));
+  } else {
+    success(`Profile "${name}" created.`);
+    console.log(`${DIM}Switch to it with: hissuno profile use ${name}${RESET}
+`);
+  }
+});
+profileCommand.command("delete <name>").description("Remove a profile").action((name, _, cmd) => {
+  const json = getJson(cmd);
+  migrateToMultiProfile();
+  try {
+    deleteProfile(name);
+  } catch (err) {
+    if (json) {
+      console.log(renderJson({ error: err.message }));
+    } else {
+      error(err.message);
+    }
+    process.exit(1);
+  }
+  if (json) {
+    console.log(renderJson({ deleted: name }));
+  } else {
+    success(`Profile "${name}" deleted.`);
+  }
+});
+
+// src/commands/skills.ts
+import { Command as Command11 } from "commander";
+import { existsSync as existsSync2, cpSync, rmSync, readdirSync, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+import { confirm as confirm9 } from "@inquirer/prompts";
+var CLAUDE_SKILLS_DIR = join2(homedir2(), ".claude", "skills", "hissuno");
+var CURSOR_SKILLS_DIR = join2(homedir2(), ".cursor", "skills", "hissuno");
+function getJson2(cmd) {
+  return cmd.parent?.parent?.opts().json ?? false;
+}
+function getBundledSkillsPath() {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const prodPath = join2(thisDir, "..", "..", "skills");
+  if (existsSync2(join2(prodPath, "SKILL.md"))) return prodPath;
+  const devPath = join2(thisDir, "..", "..", "..", "skills", "hissuno");
+  if (existsSync2(join2(devPath, "SKILL.md"))) return devPath;
+  throw new Error("Bundled skills not found. Package may be corrupted.");
+}
+function countFiles(dir) {
+  if (!existsSync2(dir)) return 0;
+  let count = 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isFile()) count++;
+    else if (entry.isDirectory()) count += countFiles(join2(dir, entry.name));
+  }
+  return count;
+}
+function getLocationInfo(name, path7) {
+  const installed = existsSync2(path7) && existsSync2(join2(path7, "SKILL.md"));
+  return { name, path: path7, installed, fileCount: installed ? countFiles(path7) : 0 };
+}
+function resolveTargetDir(opts) {
+  if (opts.path) return opts.path;
+  if (opts.cursor) return CURSOR_SKILLS_DIR;
+  return CLAUDE_SKILLS_DIR;
+}
+var skillsCommand = new Command11("skills").description("Install Hissuno skills into agent environments");
+skillsCommand.command("install").description("Install Hissuno skills").option("--cursor", "Install to Cursor skills directory").option("--path <dir>", "Install to a custom directory").option("--force", "Overwrite without prompting").action(async (opts, cmd) => {
+  const json = getJson2(cmd);
+  if (opts.cursor && opts.path) {
+    if (json) {
+      console.log(renderJson({ error: "--cursor and --path are mutually exclusive" }));
+    } else {
+      error("--cursor and --path are mutually exclusive.");
+    }
+    process.exit(1);
+  }
+  let srcDir;
+  try {
+    srcDir = getBundledSkillsPath();
+  } catch (err) {
+    if (json) {
+      console.log(renderJson({ error: err.message }));
+    } else {
+      error(err.message);
+    }
+    process.exit(1);
+  }
+  const destDir = resolveTargetDir(opts);
+  if (existsSync2(destDir) && existsSync2(join2(destDir, "SKILL.md")) && !opts.force) {
+    const overwrite = await confirm9({
+      message: `Skills already installed at ${destDir}. Overwrite?`,
+      default: false
+    });
+    if (!overwrite) {
+      console.log("Skipped.");
+      return;
+    }
+  }
+  const parentDir = dirname(destDir);
+  if (!existsSync2(parentDir)) {
+    mkdirSync2(parentDir, { recursive: true });
+  }
+  if (existsSync2(destDir)) {
+    rmSync(destDir, { recursive: true });
+  }
+  cpSync(srcDir, destDir, { recursive: true });
+  const fileCount = countFiles(destDir);
+  if (json) {
+    console.log(renderJson({ installed: true, path: destDir, files: fileCount }));
+  } else {
+    success(`Skills installed to ${destDir} (${fileCount} files)`);
+  }
+});
+skillsCommand.command("uninstall").description("Remove installed skills").option("--cursor", "Uninstall from Cursor skills directory").option("--path <dir>", "Uninstall from a custom directory").action((opts, cmd) => {
+  const json = getJson2(cmd);
+  if (opts.cursor && opts.path) {
+    if (json) {
+      console.log(renderJson({ error: "--cursor and --path are mutually exclusive" }));
+    } else {
+      error("--cursor and --path are mutually exclusive.");
+    }
+    process.exit(1);
+  }
+  const destDir = resolveTargetDir(opts);
+  if (!existsSync2(destDir)) {
+    if (json) {
+      console.log(renderJson({ error: "Skills not installed at this location" }));
+    } else {
+      warn(`Skills not installed at ${destDir}`);
+    }
+    return;
+  }
+  rmSync(destDir, { recursive: true });
+  if (json) {
+    console.log(renderJson({ uninstalled: true, path: destDir }));
+  } else {
+    success(`Skills removed from ${destDir}`);
+  }
+});
+skillsCommand.command("status").description("Check skills installation status").action((_, cmd) => {
+  const json = getJson2(cmd);
+  const locations = [
+    getLocationInfo("Claude Code", CLAUDE_SKILLS_DIR),
+    getLocationInfo("Cursor", CURSOR_SKILLS_DIR)
+  ];
+  if (json) {
+    console.log(renderJson(locations.map((l) => ({
+      name: l.name,
+      path: l.path,
+      installed: l.installed,
+      files: l.fileCount
+    }))));
+    return;
+  }
+  console.log(`
+  ${BOLD}${CYAN}Skills Installation${RESET}
+`);
+  for (const loc of locations) {
+    const status = loc.installed ? `${GREEN}Installed${RESET}  ${loc.path} (${loc.fileCount} files)` : `${DIM}Not found${RESET}`;
+    console.log(`  ${BOLD}${loc.name.padEnd(12)}${RESET} ${status}`);
+  }
+  console.log();
+});
+
+// src/commands/status.ts
+import { Command as Command12 } from "commander";
+var BOLD4 = "\x1B[1m";
+var DIM4 = "\x1B[2m";
+var RESET4 = "\x1B[0m";
+var GREEN3 = "\x1B[32m";
+var RED3 = "\x1B[31m";
+var CYAN4 = "\x1B[36m";
+var YELLOW3 = "\x1B[33m";
+var statusCommand = new Command12("status").description("Check connection health").action(async () => {
+  const config = loadConfig();
+  if (!config) {
+    console.log(`
+  ${RED3}Not configured${RESET4}`);
+    console.log(`  ${DIM4}Run \`hissuno config\` to set up your API key and URL.${RESET4}
+`);
+    process.exit(1);
+  }
+  console.log(`
+  ${BOLD4}${CYAN4}Hissuno Status${RESET4}
+`);
+  console.log(`  ${DIM4}URL:${RESET4}     ${config.base_url}`);
+  console.log(`  ${DIM4}API Key:${RESET4} ${config.api_key.slice(0, 8)}${"*".repeat(12)}`);
+  if (config.project_id) {
+    console.log(`  ${DIM4}Project:${RESET4} ${config.project_id}`);
+  }
+  process.stdout.write(`
+  Checking connection... `);
+  try {
+    const result = await apiCall(config, "GET", "/api/projects");
+    if (!result.ok) {
+      console.log(`${RED3}failed${RESET4}`);
+      console.log(`  ${RED3}HTTP ${result.status}${RESET4}`);
+      if (result.status === 401) {
+        console.log(`  ${DIM4}Your API key may be invalid or expired. Run \`hissuno config\` to reconfigure.${RESET4}`);
+      }
+      console.log();
+      process.exit(1);
+    }
+    console.log(`${GREEN3}connected${RESET4}`);
+    const projects = Array.isArray(result.data) ? result.data : result.data?.projects;
+    if (Array.isArray(projects) && projects.length > 0) {
+      const project = projects[0];
+      console.log(`  ${DIM4}Project:${RESET4} ${project.name} (${project.id})`);
+    }
+    console.log();
+  } catch (err) {
+    console.log(`${RED3}failed${RESET4}`);
+    const message = err instanceof Error ? err.message : "Unknown error";
+    if (message.includes("ECONNREFUSED")) {
+      console.log(`  ${YELLOW3}Server not reachable at ${config.base_url}${RESET4}`);
+      console.log(`  ${DIM4}Is your Hissuno instance running?${RESET4}`);
+    } else if (message.includes("ENOTFOUND")) {
+      console.log(`  ${YELLOW3}Host not found: ${config.base_url}${RESET4}`);
+      console.log(`  ${DIM4}Check the URL in your config. Run \`hissuno config\` to update.${RESET4}`);
+    } else {
+      console.log(`  ${RED3}${message}${RESET4}`);
+    }
+    console.log();
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command13().name("hissuno").description("Hissuno CLI - set up, configure, and query your product intelligence data").version("0.2.0").option("--json", "Output as JSON");
+program.addCommand(setupCommand);
+program.addCommand(configCommand);
+program.addCommand(profileCommand);
+program.addCommand(skillsCommand);
+program.addCommand(statusCommand);
+program.addCommand(typesCommand);
+program.addCommand(listCommand);
+program.addCommand(getCommand);
+program.addCommand(searchCommand);
+program.addCommand(addCommand);
+program.addCommand(updateCommand);
+program.addCommand(integrateCommand);
+program.parseAsync(process.argv);