@series-a/cli 0.2.1 → 0.6.2

package/src/commands/resources.mjs

@@ -110,6 +110,77 @@ export function registerLeads(program) {
       } catch (e) { fail(e); }
     });
 
+  withCommonOpts(leads.command("import-from <source>"))
+    .description("Import leads from any source: linkedin_search | company_search | post_reactors | paste_profiles | csv | heyreach")
+    .option("--query <q>", "search keywords (linkedin_search / company_search)")
+    .option("--post <url>", "LinkedIn post URL (post_reactors)")
+    .option("--file <path>", "CSV or pasted-profile text file (csv / paste_profiles / heyreach)")
+    .option("--audience <name>", "audience (segment) name or id to attach to")
+    .option("--campaign <id>", "campaign id (required for heyreach)")
+    .option("--limit <n>", "max prospects for LinkedIn sources", "50")
+    .option("--no-enrich", "skip the LinkedIn verify + enrich chain")
+    .action(async function (source) {
+      try {
+        const o = this.optsWithGlobals();
+        const params = {
+          source,
+          query: o.query,
+          post_url: o.post,
+          audience: o.audience,
+          campaign_id: o.campaign,
+          limit: Number(o.limit),
+          enrich: o.enrich !== false,
+        };
+        if (o.file) {
+          const text = await readFile(o.file, "utf8");
+          if (source === "paste_profiles") params.text = text;
+          else params.csv = text;
+        }
+        const r = await call("leads", "import", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `✓ Imported ${d.imported ?? 0} leads (${d.duplicates ?? 0} duplicates, ${d.skipped ?? 0} skipped, ${d.failed ?? 0} failed)\n` +
+          (d.job_id ? `  job: ${d.job_id}\n` : "")));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("import-status <jobId>"))
+    .description("Poll a running lead import")
+    .action(async function (jobId) {
+      try {
+        const r = await call("leads", "import_status", { job_id: jobId }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.job, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("update <id>"))
+    .description("Update a single lead")
+    .option("--name <v>").option("--title <v>").option("--company <v>")
+    .option("--email <v>").option("--linkedin <v>").option("--persona <v>")
+    .option("--score <n>").option("--status <v>").option("--notes <v>")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const params = { id };
+        for (const [k, v] of Object.entries({
+          name: o.name, title: o.title, company: o.company, email: o.email,
+          linkedin_url: o.linkedin, persona_tag: o.persona,
+          score: o.score !== undefined ? Number(o.score) : undefined,
+          status: o.status, notes: o.notes,
+        })) if (v !== undefined) params[k] = v;
+        const r = await call("leads", "update", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.lead?.name ?? id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("delete <id>"))
+    .description("Delete a lead")
+    .action(async function (id) {
+      try {
+        const r = await call("leads", "delete", { id }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write(`✓ Deleted ${id}\n`));
+      } catch (e) { fail(e); }
+    });
+
   withCommonOpts(leads.command("verify <id>"))
     .description("Run LinkedIn verification on a lead")
     .action(async function (id) {
@@ -175,6 +246,33 @@ export function registerCampaigns(program) {
       } catch (e) { fail(e); }
     });
 
+  withCommonOpts(c.command("update <campaignId>"))
+    .description("Edit an existing campaign")
+    .option("--name <name>", "rename campaign")
+    .option("--description <text>", "description")
+    .option("--goal <text>", "campaign goal")
+    .option("--sequence <id>", "attach a sequence")
+    .option("--senders <csv>", "comma-separated sender_account_ids")
+    .option("--daily-limit <n>", "daily send cap")
+    .option("--status <status>", "draft|active|paused|completed|archived")
+    .action(async function (campaignId, opts) {
+      try {
+        const payload = { id: campaignId };
+        if (opts.name !== undefined) payload.name = opts.name;
+        if (opts.description !== undefined) payload.description = opts.description;
+        if (opts.goal !== undefined) payload.goal = opts.goal;
+        if (opts.sequence !== undefined) payload.sequence_id = opts.sequence;
+        if (opts.senders !== undefined) {
+          payload.sender_accounts = opts.senders.split(",").map((s) => s.trim()).filter(Boolean);
+        }
+        if (opts.dailyLimit !== undefined) payload.daily_send_limit = Number(opts.dailyLimit);
+        if (opts.status !== undefined) payload.status = opts.status;
+        const r = await call("campaigns", "update", payload, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated campaign ${d.campaign?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+
   withCommonOpts(c.command("add-leads <campaignId>"))
     .description("Attach leads to a campaign")
     .option("--lead-ids <csv>", "comma-separated lead UUIDs")
@@ -300,14 +398,19 @@ export function registerSequences(program) {
 
   withCommonOpts(s.command("add-step <id>"))
     .description("Append a step to a sequence")
-    .requiredOption("--action <action>", "viewProfile|addReaction|addComment|sendInvitation|sendMessage|wait")
-    .option("--text <message>", "message_content (required for addComment/sendInvitation/sendMessage)")
+    .requiredOption(
+      "--action <action>",
+      "viewProfile|addReaction|sendInvitation|sendMessage|loopBack|createOpportunity|enrichLead|ifAccepted|ifReplied|ifConnection|ifNetworkDistance|stopOnReply|wait|wait_3h|wait_1d|wait_2d|wait_3d|wait_5d",
+    )
+    .option("--text <message>", "message_content (required for sendInvitation/sendMessage)")
     .option("--delay <days>", "delay_days before this step", "0")
     .option("--variant <v>", "variant label", "A")
-    .option("--step-type <t>", "action|branch|wait", "action")
-    .option("--channel <c>", "channel", "linkedin")
-    .option("--branch <label>", "branch_label (for branching steps)")
-    .option("--parent-step <id>", "parent_step_id (for branches)")
+    .option("--step-type <t>", "action|condition|delay (defaults from --action)")
+    .option("--channel <c>", "channel (defaults from --action)")
+    .option("--branch <label>", "branch_label: yes|no|first|second_or_third|follower|out_of_network (children of a condition)")
+    .option("--parent-step <id>", "parent_step_id (defaults to the tail of the sequence)")
+    .option("--root", "start a new root step instead of appending to the tail (rarely correct)")
+
     .option("--order <n>", "explicit step_order (defaults to max+1)")
     .action(async function (id, opts) {
       try {
@@ -321,15 +424,49 @@ export function registerSequences(program) {
           channel: opts.channel,
           branch_label: opts.branch,
           parent_step_id: opts.parentStep,
+          root: opts.root === true,
           step_order: opts.order ? Number(opts.order) : undefined,
         }, ctxFrom(this));
         emit(this, r, (d) => {
           const st = d.step || {};
-          process.stdout.write(`✓ Added step ${st.id}\n  #${st.step_order} ${st.action} (${st.channel}) delay=${st.delay_days}d variant=${st.variant}\n`);
+          process.stdout.write(`✓ Added step ${st.id}\n  #${st.step_order} ${st.action} (${st.channel}) delay=${st.delay_days}d variant=${st.variant}\n  parent=${st.parent_step_id || "root"}${st.branch_label ? ` branch=${st.branch_label}` : ""}\n`);
+          for (const w of d.graph?.warnings || []) process.stdout.write(`  ⚠ ${w.message}\n`);
+        });
+      } catch (e) { fail(e); }
+
+    });
+
+  withCommonOpts(s.command("replace-steps <id>"))
+    .description("Replace every step of a sequence with a validated tree from a JSON file (atomic)")
+    .requiredOption("--file <path>", "JSON file: [{ temp_id, parent, branch_label, action, message_content, delay_days }]")
+    .option("--dry-run", "validate the graph without writing")
+    .action(async function (id, opts) {
+      try {
+        const raw = await readFile(opts.file, "utf8");
+        const parsed = JSON.parse(raw);
+        const steps = Array.isArray(parsed) ? parsed : parsed.steps;
+        if (!Array.isArray(steps)) throw new Error("file must contain an array of steps or { steps: [...] }");
+        const r = await call("sequences", "replace_steps", {
+          sequence_id: id,
+          steps,
+          dry_run: opts.dryRun === true,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          if (d.dry_run) {
+            process.stdout.write(`✓ Graph valid — ${d.planned_steps} step(s), nothing written\n`);
+            return;
+          }
+          process.stdout.write(`✓ Replaced steps on ${d.sequence_id} — ${d.replaced_steps} step(s)\n`);
+          for (const st of d.steps || []) {
+            process.stdout.write(`  #${st.step_order} ${st.action}${st.branch_label ? ` [${st.branch_label}]` : ""} parent=${st.parent_step_id || "root"}\n`);
+          }
+          for (const w of d.graph?.warnings || []) process.stdout.write(`  ⚠ ${w.message}\n`);
         });
       } catch (e) { fail(e); }
     });
 
+
+
   withCommonOpts(s.command("clone <id>"))
     .description("Duplicate a sequence (and all its steps) as a new draft")
     .option("--name <name>", "name for the clone (default: '<src> (copy)')")
@@ -552,6 +689,8 @@ export function registerKnowledge(program) {
     .option("--visibility <v>", "workspace | private (default: workspace)")
     .option("--no-summarize", "skip AI auto-tag/classify (raw insert only)")
     .option("--no-scrape", "skip Firecrawl scrape for --url (URL stored as bookmark)")
+    .option("--style-reference", "flag as a Tone-of-Voice style reference (for known author documents)")
+    .option("--auto-style", "score as a style reference on arrival and auto-flag if it meets the threshold (default 70)")
     .action(async function (opts) {
       try {
         const sources = [opts.url, opts.text, opts.file].filter(Boolean);
@@ -575,6 +714,8 @@ export function registerKnowledge(program) {
           visibility: opts.visibility,
           skip_summarize: opts.summarize === false ? true : undefined,
           skip_scrape: opts.scrape === false ? true : undefined,
+          is_style_reference: opts.styleReference === true ? true : undefined,
+          auto_style_reference: opts.autoStyle === true ? true : undefined,
         };
         const r = await call("knowledge", "add", params, ctxFrom(this));
         emit(this, r, (d) => {
@@ -586,7 +727,11 @@ export function registerKnowledge(program) {
             `  category: ${it.category}\n` +
             `  tags:     ${(it.tags || []).join(", ") || "(none)"}\n` +
             (it.summary ? `  summary:  ${truncate(it.summary, 240)}\n` : "") +
-            (d.ai?.success === false ? `  ⚠ AI classify: ${d.ai.error}\n` : ""),
+            (it.is_style_reference ? `  ★ style reference\n` : "") +
+            (d.ai?.success === false ? `  ⚠ AI classify: ${d.ai.error}\n` : "") +
+            (d.style_reference_triage?.data?.results?.[0] && !it.is_style_reference
+              ? `  style triage: ${d.style_reference_triage.data.results[0].score}/100 — ${d.style_reference_triage.data.results[0].reason}\n`
+              : ""),
           );
         });
       } catch (e) { fail(e); }
@@ -599,6 +744,7 @@ export function registerKnowledge(program) {
     .option("--category <c>", "set category")
     .option("--tags <csv>", "replace tags (comma-separated)")
     .option("--visibility <v>", "workspace | private")
+    .option("--style-reference <on|off>", "flag/unflag as a Tone-of-Voice style reference")
     .action(async function (id, opts) {
       try {
         const patch = {
@@ -608,6 +754,7 @@ export function registerKnowledge(program) {
           category: opts.category,
           tags: opts.tags ? opts.tags.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
           visibility: opts.visibility,
+          is_style_reference: opts.styleReference === "on" ? true : opts.styleReference === "off" ? false : undefined,
         };
         const r = await call("knowledge", "update", patch, ctxFrom(this));
         emit(this, r, (d) => process.stdout.write(`✓ Updated ${d.item?.id}\n`));
@@ -759,8 +906,51 @@ export function registerContent(program) {
         emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(c.command("generate"))
+    .description("Generate a draft via agent-content-creator (KB + reference library grounded, URL-sanitised, citations recorded)")
+    .requiredOption("--angle <text>", "topic / angle for the draft")
+    .option("--format <f>", "blog | linkedin_post | video | explainer_video", "blog")
+    .option("--signal <id...>", "intelligence_signals ids to ground on (repeatable)")
+    .option("--reference <id...>", "knowledge_items ids to ground on (repeatable)")
+    .option("--grounding-text <text>", "extra freeform grounding to append")
+    .option("--wait", "block until the job completes (up to 4 min)")
+    .action(async function (opts) {
+      try {
+        const r = await call("content", "generate", {
+          angle: opts.angle,
+          format: opts.format,
+          signal_ids: opts.signal,
+          reference_item_ids: opts.reference,
+          grounding_text: opts.groundingText,
+          async: !opts.wait,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          if (d.content) {
+            process.stdout.write(`✓ Draft ${d.content.id} (${d.content.type}, ${d.citations?.length ?? 0} citations)\n`);
+          } else {
+            process.stdout.write(`⏳ Queued job ${d.job_id} — poll with: advisoros agents job-status ${d.job_id}\n`);
+          }
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("citations <id>"))
+    .description("List every source (signal, reference, transcript, published) recorded for a content item")
+    .action(async function (id) {
+      try {
+        const r = await call("content", "citations", { id }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["kind", "id", "title", "url"],
+            (d.citations || []).map((c) => [c.source_kind, truncate(c.source_id ?? "", 8), truncate(c.title ?? "", 40), truncate(c.source_url ?? "", 60)]),
+          ) + `\n${d.citations?.length ?? 0} citations\n`);
+        });
+      } catch (e) { fail(e); }
+    });
 }
 
+
 export function registerCalendar(program) {
   const cal = program.command("calendar").description("Manage the content calendar");
 
@@ -1104,6 +1294,42 @@ export function registerPipelines(program) {
 export function registerAgents(program) {
   const a = program.command("agents").description("List, create, configure and invoke agents");
 
+  withCommonOpts(a.command("trigger <name>"))
+    .description("Trigger an agent by name with optional JSON input")
+    .option("--input <json>", "JSON input payload", "{}")
+    .action(async function (name) {
+      try {
+        const o = this.optsWithGlobals();
+        let input = {};
+        try { input = JSON.parse(o.input); } catch { throw new Error("--input must be valid JSON"); }
+        const r = await call("agents", "trigger", { agent_name: name, input }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.run, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("history"))
+    .description("Recent agent runs and jobs")
+    .option("--agent <name>", "filter by agent name")
+    .option("--days <n>", "look-back window", "30")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("agents", "history", {
+          agent_name: o.agent, days: Number(o.days), limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["when", "agent", "status", "results"],
+            (d.runs || []).map((x) => [
+              String(x.created_at ?? "").slice(0, 16), truncate(x.agent_name, 30),
+              x.status ?? "", String(x.results_count ?? ""),
+            ]),
+          ) + `\n${d.runs?.length ?? 0} runs, ${d.jobs?.length ?? 0} jobs\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
   withCommonOpts(a.command("list"))
     .description("List available agents")
     .option("--scope <s>", "workspace | global | both (default: both)")

package/src/index.mjs

@@ -6,14 +6,21 @@ import {
   registerCalendar, registerSignals, registerPipelines, registerAuthority,
   registerBriefs,
 } from "./commands/resources.mjs";
+import {
+  registerCampaignAnalytics, registerAnalytics, registerSafety, registerCtas,
+  registerNotifications, registerAudiences, registerNewsletter, registerVideo,
+  registerWatchlist, registerMeetings, registerActivity, registerWorkspacesExtras,
+  registerExport, registerIntegrations,
+} from "./commands/insights.mjs";
 import { registerFlow } from "./commands/flow.mjs";
+import { registerVaultSync } from "./commands/knowledge-sync.mjs";
 
 const program = new Command();
 
 program
   .name("advisoros")
-  .description("AdvisorOS CLI — drive leads, campaigns, sequences and agents from your terminal.")
-  .version("0.1.0")
+  .description("AdvisorPro CLI — drive leads, campaigns, sequences and agents from your terminal.")
+  .version("0.5.0")
   .option("--json", "machine-readable JSON output (applies to all subcommands)");
 
 registerAuth(program);
@@ -29,9 +36,29 @@ registerPipelines(program);
 registerAuthority(program);
 registerBriefs(program);
 registerAgents(program);
+registerIntegrations(program);
+
+// Analytics, safety guardrails and the remaining resource surface.
+registerCampaignAnalytics(program);
+registerAnalytics(program);
+registerSafety(program);
+registerCtas(program);
+registerNotifications(program);
+registerAudiences(program);
+registerNewsletter(program);
+registerVideo(program);
+registerWatchlist(program);
+registerMeetings(program);
+registerActivity(program);
+registerWorkspacesExtras(program);
+registerExport(program);
+
+registerVaultSync(program);
+
 registerFlow(program);
 
 program.parseAsync(process.argv).catch((e) => {
   process.stderr.write(`✖ ${e?.message ?? e}\n`);
   process.exit(1);
 });
+