innernote 0.2.0 → 0.3.1

package/README.md

@@ -78,18 +78,28 @@ any time.
 
 ## Commands
 
+The table below is asserted by `cli/src/parity.test.ts`: a command missing
+from it fails the suite, so what you read here is what the binary has.
+
 | Command | What it does |
 | --- | --- |
 | `login [code]` | connect this machine |
 | `logout` | forget the token stored here |
-| `whoami` | show which account is connected |
+| `whoami` | show which account is connected, and what this key can do |
+| `context` | what you post about: your pillars and your series |
 | `capture <text>` | save an idea to your inbox |
 | `write [topic]` | draft a post in your voice |
+| `shape <shape...>` | push a post shorter, punchier, warmer |
+| `ask <anything>` | talk to the post in your own words |
+| `save` | keep the draft you are holding |
+| `show` | reprint the post you are holding |
+| `drop` | put down whatever you are holding |
+| `open <n or id>` | pull a post out of the last list and work on it |
 | `ideas [status]` | list what you have captured |
-| `drafts [status]` | list your posts, with their ids |
+| `drafts [status]` | list your posts, numbered |
 | `week` | what is scheduled for the next seven days |
-| `shape <shape...>` | push a post shorter, punchier, warmer (reads stdin) |
 | `queue <post-id>` | schedule a post into your next open slot |
+| `unqueue <post-id>` | pull it back out before it goes live |
 
 ### write
 

package/dist/index.js

@@ -609,6 +609,42 @@ async function week(args) {
   }
   return 0;
 }
+async function context(args) {
+  const { json } = parseFlags(args);
+  const [pillars, series] = await Promise.all([
+    request("/api/pillars"),
+    request("/api/campaigns")
+  ]);
+  if (json) {
+    out(JSON.stringify({ pillars: pillars.pillars, series: series.campaigns }, null, 2));
+    return 0;
+  }
+  out();
+  if (pillars.pillars.length) {
+    out(`  ${bold2("What you post about")}`);
+    for (const p of pillars.pillars) {
+      out(`    ${caramel(p.name)}${typeof p.weight === "number" ? dim2(`   ${p.weight}%`) : ""}`);
+    }
+  } else {
+    out(`  ${dim2("No content pillars yet. Set them in Settings.")}`);
+  }
+  out();
+  if (series.campaigns.length) {
+    out(`  ${bold2("Series")}${dim2("   write into one with")} ${caramel('write --series "<name>"')}`);
+    for (const c of series.campaigns) {
+      const count = typeof c.postCount === "number" && c.postCount > 0 ? dim2(`   ${c.postCount} ${c.postCount === 1 ? "post" : "posts"}`) : "";
+      out(`    ${caramel(c.name)}${count}`);
+      if (c.brief)
+        out(`      ${dim2(oneLine(c.brief, 64))}`);
+      if (c.goal)
+        out(`      ${dim2(`goal: ${oneLine(c.goal, 58)}`)}`);
+    }
+  } else {
+    out(`  ${dim2("No series running.")}`);
+  }
+  out();
+  return 0;
+}
 
 // src/commands/read.ts
 function parseFlags2(args) {
@@ -1078,6 +1114,23 @@ async function drop() {
   note(dim2("`write` to start something, or `drafts` to pick one up"));
   return 0;
 }
+async function unqueue(args) {
+  const { json, rest } = parseFlags2(args);
+  const ref = rest[0] ? resolveRef(rest[0]) : null;
+  if (!ref) {
+    fail("Which post?");
+    note(dim2(`${CMD} unqueue <post-id>   (\`${CMD} week\` shows what is queued)`));
+    return 1;
+  }
+  const result = await request(`/api/linkedin/schedule/${encodeURIComponent(ref.id)}`, { method: "DELETE" });
+  if (json) {
+    out(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  ok("Pulled back out of the queue. It is a draft again.");
+  note(dim2("`drafts` to find it, `queue` to send it back"));
+  return 0;
+}
 
 // src/ui.ts
 var useColor2 = process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.TERM !== "dumb";
@@ -1316,6 +1369,18 @@ var COMMANDS = {
     usage: "innernote week",
     detail: "Seven days across, so the gaps are visible before you read a word. Published is filled, scheduled is open."
   },
+  unqueue: {
+    summary: "pull a post back out of the queue before it goes live",
+    usage: "innernote unqueue <post-id>",
+    detail: "The undo for queue, while there is still time. The post returns to your drafts and nothing goes live. Once it has been published this refuses, because a live post cannot be unsent this way.",
+    examples: ["innernote unqueue p17abc...", "innernote unqueue 3"]
+  },
+  context: {
+    summary: "what you post about: your pillars and your series",
+    usage: "innernote context",
+    detail: "Your standing context: content pillars with their weights, and every running series with what it is about and what it is for. This is the thing to read before deciding what to write, and the thing an agent should read first for the same reason. --json prints the raw payload for scripts and models.",
+    examples: ["innernote context", "innernote context --json"]
+  },
   queue: {
     summary: "schedule a post into your next open slot",
     usage: "innernote queue <post-id>",
@@ -1433,7 +1498,7 @@ function suggest(state) {
 // package.json
 var package_default = {
   name: "innernote",
-  version: "0.2.0",
+  version: "0.3.1",
   description: "Write LinkedIn posts in your voice, from the terminal.",
   type: "module",
   bin: {
@@ -1441,6 +1506,7 @@ var package_default = {
   },
   files: [
     "dist",
+    "skills",
     "README.md"
   ],
   scripts: {
@@ -1654,6 +1720,18 @@ var COMMANDS2 = {
     usage: "innernote week",
     detail: "Seven days across, so the gaps are visible before you read a word. Published is filled, scheduled is open."
   },
+  unqueue: {
+    summary: "pull a post back out of the queue before it goes live",
+    usage: "innernote unqueue <post-id>",
+    detail: "The undo for queue, while there is still time. The post returns to your drafts and nothing goes live. Once it has been published this refuses, because a live post cannot be unsent this way.",
+    examples: ["innernote unqueue p17abc...", "innernote unqueue 3"]
+  },
+  context: {
+    summary: "what you post about: your pillars and your series",
+    usage: "innernote context",
+    detail: "Your standing context: content pillars with their weights, and every running series with what it is about and what it is for. This is the thing to read before deciding what to write, and the thing an agent should read first for the same reason. --json prints the raw payload for scripts and models.",
+    examples: ["innernote context", "innernote context --json"]
+  },
   queue: {
     summary: "schedule a post into your next open slot",
     usage: "innernote queue <post-id>",
@@ -1914,8 +1992,8 @@ function whatThereIs() {
   ];
   const groups = [
     ["Writing", ["write", "shape", "ask", "save", "capture"]],
-    ["Looking", ["show", "ideas", "drafts", "open", "week", "whoami"]],
-    ["Shipping", ["queue"]],
+    ["Looking", ["show", "ideas", "drafts", "open", "week", "context", "whoami"]],
+    ["Shipping", ["queue", "unqueue"]],
     ["Connection", ["login", "logout"]]
   ];
   for (const [title, cmds] of groups) {
@@ -1944,8 +2022,8 @@ function commandList() {
   const groups = [
     ["Getting connected", ["login", "logout", "whoami"]],
     ["Writing", ["write", "shape", "ask", "save", "capture"]],
-    ["Looking", ["show", "ideas", "drafts", "open", "week"]],
-    ["Shipping", ["queue"]]
+    ["Looking", ["show", "ideas", "drafts", "open", "week", "context"]],
+    ["Shipping", ["queue", "unqueue"]]
   ];
   const lines = [];
   for (const [title, names] of groups) {
@@ -1970,6 +2048,7 @@ var HELP = () => [
 ].join(`
 `);
 var COMMANDS3 = {
+  context,
   login,
   logout: () => logout(),
   whoami,
@@ -1984,7 +2063,8 @@ var COMMANDS3 = {
   drafts,
   open,
   week,
-  queue
+  queue,
+  unqueue
 };
 async function main() {
   const [, , command, ...args] = process.argv;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "innernote",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Write LinkedIn posts in your voice, from the terminal.",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "dist",
+    "skills",
     "README.md"
   ],
   "scripts": {

package/skills/innernote-cli/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: innernote-cli
+description: Drive the innernote CLI (`npx innernote`) to help someone write, save and schedule LinkedIn posts in their own voice from the terminal. Use this whenever the user mentions innernote, asks to draft or queue a LinkedIn post from the command line, wants their posting week or captured ideas checked, or asks you to capture a thought for later, even if they do not name the CLI. Also use it before touching any `innernote` command in a script.
+---
+
+# Driving the innernote CLI
+
+innernote holds this person's writing voice: how they write, what they post
+about, and their posting schedule. The CLI is a thin client over the same
+service the app uses, so a draft made here sounds like THEM, not like you,
+and everything you save appears in their app.
+
+## The contract, before any command
+
+- **stdout is data, stderr is narration.** The post text, JSON and ids go to
+  stdout; spinners, notes and errors go to stderr. Pipe stdout with
+  confidence, and never parse the human-facing view: every read command takes
+  `--json`, which prints the API payload and nothing else.
+- **Exit codes are the protocol.** `0` worked. `1` failed, reason on stderr.
+  `2` not connected: stop and ask the user to run `npx innernote login`.
+  `3` the account cannot do this right now: a paywall or a spent allowance,
+  never a bug. Only `1` is worth debugging.
+- **A refusal is a sentence for the user, not an obstacle for you.** When a
+  command refuses (a limit, a missing cadence, no such post), the message is
+  already written for the person. Show it to them verbatim and stop. Do not
+  retry, and do not work around it.
+
+## Connecting
+
+Check with `innernote whoami` (exit `2` means not connected). Connecting
+needs a pairing code from the user's Settings page at
+innernote.space/dashboard/settings; you cannot get one yourself. Ask them
+for it, then run `innernote login THEIR-CODE`. The code works once and
+expires in ten minutes. `INNERNOTE_TOKEN` in the environment overrides the
+stored key, which is how CI and scripts authenticate.
+
+## Read before you write
+
+Suggestions that ignore what this person posts about are generic advice,
+which is the one thing innernote exists to prevent.
+
+```bash
+innernote context --json    # their content pillars and running series
+innernote week --json       # what is scheduled over the next seven days
+innernote ideas --json      # thoughts they captured and have not written
+innernote drafts --json     # saved posts, newest first, with ids
+```
+
+Start with `context` and `week` when helping them decide what to write: an
+empty week is a real answer, and a post should land inside a pillar or a
+series they have committed to.
+
+## The writing loop
+
+**Capture** the moment something is worth posting about later:
+
+```bash
+innernote capture "their thought, in their words"
+git log --oneline -20 | innernote capture      # stdin works too
+```
+
+Capture their framing, not your tidied summary. Their phrasing carries their
+voice; a summary throws it away.
+
+**Draft and keep** in one command:
+
+```bash
+innernote write "their rough thought or topic, in their words" --save
+innernote write "next part of the hiring story" --series "Build in Public" --save
+```
+
+Pass their OWN WORDS as the argument, as fully as you have them. `write`
+takes a whole messy thought, and any shaping you already know they want
+(shorter, no list, warmer ending) belongs in that ask, phrased plainly.
+`--series` takes the series NAME; a wrong name refuses with the real list,
+so correct from that and retry once. The saved id is printed on stderr and
+`innernote drafts --json` lists it first.
+
+**Shaping an already-saved post is not yours to finish here.** Each CLI
+invocation is a fresh process, so the flag form of `shape` transforms
+stdin to stdout without saving:
+
+```bash
+innernote shape shorter punchier < draft.txt   # transformed text, NOT saved
+```
+
+Use that for showing the person options. To revise and keep, fold the
+direction into a fresh `write ... --save`, or hand them to the app or the
+interactive session (`innernote` on its own), where reshaping a held draft
+does persist.
+
+## Scheduling: the one action that reaches other people
+
+`innernote queue <id>` schedules a saved post into their next open slot,
+and it then goes live on LinkedIn on its own. Nobody presses anything
+again, and a live post cannot be unsent.
+
+So queue ONLY when the user has clearly told you to queue that specific
+post. Never as a helpful next step, never to tidy up. If they have not said
+so, tell them it is saved and stop. The undo exists while it is still
+pending:
+
+```bash
+innernote queue p17abc...     # their explicit ask, and only then
+innernote unqueue p17abc...   # back to drafts, nothing goes out
+```
+
+If `queue` exits `3`, their plan or allowance is the reason; show the
+message, which says where to fix it, and leave the decision with them.
+
+## Worked example
+
+The user says: "turn what I told you about interview homework into a post
+for my build-in-public series, keep it short, and line it up for this week."
+
+```bash
+innernote context --json          # confirm the series name
+innernote week --json             # is there an open day?
+innernote write "interview homework filters for free time, not talent. we swapped ours for a paid 40 minute working session and offer accepts went up. keep it short." --series "Build in Public" --save
+innernote drafts --json           # take the first id
+innernote queue <that-id>         # they said "line it up": that is the go-ahead
+```
+
+Then tell them what was drafted, where it was queued, and that `unqueue`
+takes it back any time before it goes live.