postemi 1.0.1 → 1.1.0

package/dist/index.js

@@ -421,10 +421,10 @@ var PostemiAPI = class {
 };
 
 // src/commands/auth.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var import_os2 = require("os");
-var import_readline = require("readline");
+var import_fs3 = require("fs");
+var import_path4 = require("path");
+var import_os3 = require("os");
+var import_readline2 = require("readline");
 
 // src/settings.ts
 var import_fs = require("fs");
@@ -450,6 +450,9 @@ function getSetting(key) {
   return typeof value === "string" && value ? value : void 0;
 }
 function saveSetting(key, value) {
+  saveRawSetting(key, value);
+}
+function saveRawSetting(key, value) {
   if (!(0, import_fs.existsSync)(SETTINGS_DIR)) {
     (0, import_fs.mkdirSync)(SETTINGS_DIR, { recursive: true, mode: 448 });
   }
@@ -622,15 +625,345 @@ function resolveDateInput(input, timezone, flagName = "--date") {
   return { iso: instant.toISOString(), appliedTimezone: timezone };
 }
 
+// src/commands/skills.ts
+var import_os2 = require("os");
+var import_path3 = require("path");
+var import_readline = require("readline");
+
+// src/skills.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var OPTIONAL_SETS = ["writing", "growth"];
+var SKILL_SETS = {
+  core: ["postemi"],
+  writing: ["postemi-writing", "postemi-templates"],
+  growth: ["postemi-growth"]
+};
+var SET_SUMMARY = {
+  core: "the postemi commands and their rules (always on)",
+  writing: "write posts: ideas, hooks, formatting, network rules, templates",
+  growth: "grow an audience: niche, cadence, 30-day plan, weekly review"
+};
+var AGENT_IDS = ["claude", "codex", "cursor", "grok"];
+function knownAgents(home, env = {}) {
+  const claudeHome = env.CLAUDE_CONFIG_DIR || (0, import_path2.join)(home, ".claude");
+  const codexHome = env.CODEX_HOME || (0, import_path2.join)(home, ".codex");
+  const cursorHome = (0, import_path2.join)(home, ".cursor");
+  const grokHome = (0, import_path2.join)(home, ".grok");
+  return [
+    { id: "claude", name: "Claude Code", home: claudeHome, skillsDir: (0, import_path2.join)(claudeHome, "skills") },
+    { id: "codex", name: "Codex", home: codexHome, skillsDir: (0, import_path2.join)(codexHome, "skills") },
+    { id: "cursor", name: "Cursor", home: cursorHome, skillsDir: (0, import_path2.join)(cursorHome, "skills") },
+    { id: "grok", name: "Grok Build", home: grokHome, skillsDir: (0, import_path2.join)(grokHome, "skills") }
+  ];
+}
+function detectAgents(home, env = {}) {
+  return knownAgents(home, env).filter((agent) => isDir(agent.home));
+}
+function parseSetNames(names) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of names) {
+    const name = raw.trim().toLowerCase().replace(/^postemi-?/, "") || "core";
+    if (name === "all") OPTIONAL_SETS.forEach((s) => out.add(s));
+    else if (name === "templates") out.add("writing");
+    else if (name === "core" || name === "writing" || name === "growth") out.add(name);
+    else throw new Error(`Unknown skill "${raw}". Use writing, growth, all or core.`);
+  }
+  return [...out];
+}
+function isDir(path) {
+  try {
+    return (0, import_fs2.statSync)(path).isDirectory();
+  } catch (e) {
+    return false;
+  }
+}
+function listFiles(dir, prefix = "") {
+  const out = [];
+  for (const name of (0, import_fs2.readdirSync)(dir).sort()) {
+    const path = (0, import_path2.join)(dir, name);
+    if (isDir(path)) out.push(...listFiles(path, (0, import_path2.join)(prefix, name)));
+    else out.push((0, import_path2.join)(prefix, name));
+  }
+  return out;
+}
+function sameTree(a, b) {
+  const fa = listFiles(a);
+  const fb = listFiles(b);
+  return fa.length === fb.length && fa.every((f, i) => fb[i] === f && (0, import_fs2.readFileSync)((0, import_path2.join)(a, f)).equals((0, import_fs2.readFileSync)((0, import_path2.join)(b, f))));
+}
+function skillName(dir) {
+  try {
+    const text = (0, import_fs2.readFileSync)((0, import_path2.join)(dir, "SKILL.md"), "utf8");
+    const match = /^---\r?\n[\s\S]*?^name:\s*["']?([\w-]+)["']?\s*$/m.exec(text);
+    return match ? match[1] : null;
+  } catch (e) {
+    return null;
+  }
+}
+function folderState(source, folder, agent) {
+  const target = (0, import_path2.join)(agent.skillsDir, folder);
+  if (skillName(target) !== folder) return "missing";
+  return sameTree((0, import_path2.join)(source, folder), target) ? "installed" : "outdated";
+}
+function setState(source, set, agent) {
+  const states = SKILL_SETS[set].map((f) => folderState(source, f, agent));
+  if (states.includes("missing")) return "missing";
+  if (states.includes("outdated")) return "outdated";
+  return "installed";
+}
+function installSets(source, sets, agent) {
+  const folders = foldersFor(sets.includes("core") ? sets : ["core", ...sets]);
+  for (const folder of folders) {
+    if (skillName((0, import_path2.join)(source, folder)) !== folder) {
+      throw new Error(`The package has no ${folder} skill at ${(0, import_path2.join)(source, folder)}`);
+    }
+    const target = (0, import_path2.join)(agent.skillsDir, folder);
+    if ((0, import_fs2.existsSync)(target) && skillName(target) !== folder) {
+      throw new Error(`${target} exists and is not the ${folder} skill; move it away first`);
+    }
+  }
+  (0, import_fs2.mkdirSync)(agent.skillsDir, { recursive: true });
+  for (const folder of folders) {
+    const target = (0, import_path2.join)(agent.skillsDir, folder);
+    (0, import_fs2.rmSync)(target, { recursive: true, force: true });
+    (0, import_fs2.cpSync)((0, import_path2.join)(source, folder), target, { recursive: true });
+  }
+  return folders;
+}
+function removeSets(sets, agent) {
+  const removed = [];
+  for (const folder of foldersFor(sets)) {
+    const target = (0, import_path2.join)(agent.skillsDir, folder);
+    if (skillName(target) !== folder) continue;
+    (0, import_fs2.rmSync)(target, { recursive: true, force: true });
+    removed.push(folder);
+  }
+  return removed;
+}
+function foldersFor(sets) {
+  return [...new Set(sets.flatMap((s) => SKILL_SETS[s]))];
+}
+function terminalFrom(argv, env = process.env) {
+  return {
+    stdinTTY: !!process.stdin.isTTY,
+    stderrTTY: !!process.stderr.isTTY,
+    json: !!argv.json,
+    ci: !!env.CI && env.CI !== "false" && env.CI !== "0"
+  };
+}
+function canAsk(t) {
+  return t.stdinTTY && t.stderrTTY && !t.json && !t.ci;
+}
+var ANSWER_KEY = {
+  writing: "skills.writing",
+  growth: "skills.growth"
+};
+var HINT_KEY = "skills.hint";
+var QUESTIONS = {
+  writing: "Postemi can also help you write posts. Install the optional writing skill (ideas, hooks, templates)? [y/N] ",
+  growth: "Install the optional growth skill (niche, cadence, 30-day plan)? [y/N] "
+};
+var HINT = "Tip: optional agent skills for writing posts and growing an audience: postemi skills list, postemi skills add writing|growth";
+function isYes(answer) {
+  return /^(y|yes)$/i.test(answer.trim());
+}
+function alreadyOffered(store) {
+  return OPTIONAL_SETS.every((s) => !!store.get(ANSWER_KEY[s]));
+}
+async function offerOptionalSkills(deps, force = false) {
+  const { terminal, store, ask: ask3, log } = deps;
+  if (!force && alreadyOffered(store)) return [];
+  if (!canAsk(terminal)) {
+    if (!store.get(HINT_KEY)) {
+      log(HINT);
+      store.set(HINT_KEY, "shown");
+    }
+    return [];
+  }
+  const chosen = [];
+  for (const set of OPTIONAL_SETS) {
+    const yes = isYes(await ask3(QUESTIONS[set]));
+    store.set(ANSWER_KEY[set], yes ? "yes" : "no");
+    if (yes) chosen.push(set);
+  }
+  if (!chosen.length) log("No optional skills. Add them any time with: postemi skills add");
+  return chosen;
+}
+async function chooseAgents(opts) {
+  const { found, all, requested, yes, terminal, ask: ask3, log } = opts;
+  if (requested && requested.length) {
+    const ids = requested.flatMap((r) => String(r).split(",")).map((r) => r.trim().toLowerCase()).filter(Boolean);
+    if (ids.includes("all")) return found;
+    return ids.map((id) => {
+      const agent = all.find((a) => a.id === id);
+      if (!agent) throw new Error(`Unknown agent "${id}". Use ${AGENT_IDS.join(", ")} or all.`);
+      return agent;
+    });
+  }
+  if (found.length <= 1 || yes || !canAsk(terminal)) return found;
+  log("Agents found on this machine:");
+  found.forEach((a, i) => log(`  ${i + 1}. ${a.name}  (${a.skillsDir})`));
+  const answer = (await ask3(`Install for which? [all, or numbers like 1,3] `)).trim().toLowerCase();
+  if (!answer || answer === "all" || answer === "a") return found;
+  const picked = answer.split(/[\s,]+/).map((n) => found[Number(n) - 1]).filter((a) => !!a);
+  return [...new Set(picked)];
+}
+
+// src/commands/skills.ts
+function bundledSkillsDir() {
+  return (0, import_path3.join)(__dirname, "..", "skills");
+}
+var settingsStore = {
+  get: (key) => {
+    const value = loadSettings()[key];
+    return typeof value === "string" && value ? value : void 0;
+  },
+  set: (key, value) => saveRawSetting(key, value)
+};
+function ask(question) {
+  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stderr });
+  return new Promise(
+    (resolve) => rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    })
+  );
+}
+function die(message) {
+  console.error(`\u274C ${message}`);
+  process.exit(1);
+}
+async function skillsList() {
+  const source = bundledSkillsDir();
+  const settings = loadSettings();
+  const agents = knownAgents((0, import_os2.homedir)(), process.env);
+  const found = new Set(detectAgents((0, import_os2.homedir)(), process.env).map((a) => a.id));
+  const sets = ["core", ...OPTIONAL_SETS];
+  result({
+    agents: agents.map((a) => ({ id: a.id, name: a.name, found: found.has(a.id), skillsDir: a.skillsDir })),
+    skills: sets.map((set) => {
+      var _a;
+      return {
+        name: set,
+        optional: set !== "core",
+        folders: SKILL_SETS[set],
+        about: SET_SUMMARY[set],
+        answer: set === "core" ? null : (_a = settings[ANSWER_KEY[set]]) != null ? _a : null,
+        installed: Object.fromEntries(
+          agents.filter((a) => found.has(a.id)).map((a) => [a.id, setState(source, set, a)])
+        )
+      };
+    })
+  });
+}
+async function install(sets, argv, terminal) {
+  const home = (0, import_os2.homedir)();
+  const agents = await chooseAgents({
+    found: detectAgents(home, process.env),
+    all: knownAgents(home, process.env),
+    requested: argv.agent,
+    yes: !!argv.yes,
+    terminal,
+    ask,
+    log: status
+  });
+  if (!agents.length) {
+    throw new Error(
+      `No agent skill folder found (~/.claude, ~/.codex, ~/.cursor, ~/.grok). Pass --agent claude (or codex, cursor, grok) to create one.`
+    );
+  }
+  const installed = {};
+  for (const agent of agents) {
+    try {
+      installed[agent.id] = installSets(bundledSkillsDir(), sets, agent);
+    } catch (error) {
+      throw new Error(`${agent.name}: ${error.message}`);
+    }
+    status(`\u2705 ${agent.name}: ${installed[agent.id].join(", ")} in ${agent.skillsDir}`);
+  }
+  for (const set of sets) {
+    if (set !== "core") settingsStore.set(ANSWER_KEY[set], "yes");
+  }
+  status("Start a new agent session to load them.");
+  return installed;
+}
+async function skillsAdd(argv) {
+  var _a;
+  const terminal = terminalFrom(argv);
+  const names = (_a = argv.skills) != null ? _a : [];
+  let sets;
+  if (!names.length) {
+    if (terminal.json || !terminal.stdinTTY || !terminal.stderrTTY || terminal.ci) {
+      die(`Name the skill: ${BRAND.cli} skills add writing|growth|all`);
+    }
+    sets = await offerOptionalSkills({ terminal, store: settingsStore, ask, log: status }, true);
+    if (!sets.length) {
+      result({ installed: {} });
+      return;
+    }
+  } else {
+    try {
+      sets = parseSetNames(names);
+    } catch (error) {
+      die(error.message);
+    }
+  }
+  try {
+    result({ installed: await install(sets, argv, terminal) });
+  } catch (error) {
+    die(error.message);
+  }
+}
+async function skillsRemove(argv) {
+  var _a, _b;
+  const names = (_a = argv.skills) != null ? _a : [];
+  if (!names.length) die(`Name the skill: ${BRAND.cli} skills remove writing|growth|all`);
+  let sets;
+  let agents;
+  try {
+    sets = parseSetNames(names);
+    agents = await chooseAgents({
+      found: detectAgents((0, import_os2.homedir)(), process.env),
+      all: knownAgents((0, import_os2.homedir)(), process.env),
+      requested: (_b = argv.agent) != null ? _b : ["all"],
+      yes: true,
+      terminal: terminalFrom(argv),
+      ask,
+      log: status
+    });
+  } catch (error) {
+    die(error.message);
+  }
+  const removed = {};
+  for (const agent of agents) {
+    removed[agent.id] = removeSets(sets, agent);
+    if (removed[agent.id].length) status(`\u{1F5D1}\uFE0F  ${agent.name}: removed ${removed[agent.id].join(", ")}`);
+  }
+  for (const set of sets) {
+    if (set !== "core") settingsStore.set(ANSWER_KEY[set], "no");
+  }
+  result({ removed });
+}
+async function offerSkillsAfterLogin(argv) {
+  try {
+    const terminal = terminalFrom(argv);
+    const sets = await offerOptionalSkills({ terminal, store: settingsStore, ask, log: status });
+    if (sets.length) await install(sets, {}, terminal);
+  } catch (error) {
+    status(`Skills not installed: ${(error == null ? void 0 : error.message) || error}. Try: ${BRAND.cli} skills add`);
+  }
+}
+
 // src/commands/auth.ts
-var CREDENTIALS_DIR = (0, import_path2.join)((0, import_os2.homedir)(), BRAND.configDirName);
-var CREDENTIALS_FILE = (0, import_path2.join)(CREDENTIALS_DIR, "credentials.json");
+var CREDENTIALS_DIR = (0, import_path4.join)((0, import_os3.homedir)(), BRAND.configDirName);
+var CREDENTIALS_FILE = (0, import_path4.join)(CREDENTIALS_DIR, "credentials.json");
 var DEFAULT_AUTH_SERVER = BRAND.defaultAuthServer;
 var DEFAULT_API_URL = BRAND.defaultApiUrl;
 function loadCredentials() {
   try {
-    if (!(0, import_fs2.existsSync)(CREDENTIALS_FILE)) return null;
-    const data = JSON.parse((0, import_fs2.readFileSync)(CREDENTIALS_FILE, "utf-8"));
+    if (!(0, import_fs3.existsSync)(CREDENTIALS_FILE)) return null;
+    const data = JSON.parse((0, import_fs3.readFileSync)(CREDENTIALS_FILE, "utf-8"));
     if (!data.accessToken) return null;
     return data;
   } catch (e) {
@@ -638,15 +971,15 @@ function loadCredentials() {
   }
 }
 function saveCredentials(credentials) {
-  if (!(0, import_fs2.existsSync)(CREDENTIALS_DIR)) {
-    (0, import_fs2.mkdirSync)(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+  if (!(0, import_fs3.existsSync)(CREDENTIALS_DIR)) {
+    (0, import_fs3.mkdirSync)(CREDENTIALS_DIR, { recursive: true, mode: 448 });
   }
-  (0, import_fs2.writeFileSync)(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { encoding: "utf-8", mode: 384 });
-  (0, import_fs2.chmodSync)(CREDENTIALS_FILE, 384);
+  (0, import_fs3.writeFileSync)(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs3.chmodSync)(CREDENTIALS_FILE, 384);
 }
 function deleteCredentials() {
-  if ((0, import_fs2.existsSync)(CREDENTIALS_FILE)) {
-    (0, import_fs2.unlinkSync)(CREDENTIALS_FILE);
+  if ((0, import_fs3.existsSync)(CREDENTIALS_FILE)) {
+    (0, import_fs3.unlinkSync)(CREDENTIALS_FILE);
   }
 }
 function openBrowser(url) {
@@ -660,8 +993,8 @@ function openBrowser(url) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function ask(question) {
-  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stderr });
+function ask2(question) {
+  const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stderr });
   return new Promise(
     (resolve) => rl.question(question, (answer) => {
       rl.close();
@@ -673,11 +1006,11 @@ async function maybeConfigureTimezone() {
   if (getSetting("timezone")) return;
   if (!process.stdin.isTTY || !process.stderr.isTTY) return;
   const detected = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  const answer = (await ask(`
+  const answer = (await ask2(`
 Scheduling timezone: ${detected} \u2014 OK? [Y/n] `)).trim().toLowerCase();
   let timezone = detected;
   if (answer === "n" || answer === "no") {
-    const typed = (await ask(`Enter an IANA timezone name (e.g. ${BRAND.exampleTimezone}), or leave empty to skip: `)).trim();
+    const typed = (await ask2(`Enter an IANA timezone name (e.g. ${BRAND.exampleTimezone}), or leave empty to skip: `)).trim();
     if (!typed) {
       console.error(
         `Skipped. Dates without an explicit offset will be refused until you run: ${BRAND.cli} config:set timezone <IANA name>`
@@ -728,7 +1061,7 @@ async function chooseWorkspace(creds) {
     );
     return;
   }
-  const answer = (await ask(`Work in which one? [1-${workspaces.length}] `)).trim();
+  const answer = (await ask2(`Work in which one? [1-${workspaces.length}] `)).trim();
   const index = Number(answer) - 1;
   const chosen = workspaces[index];
   if (!chosen) {
@@ -809,6 +1142,7 @@ async function authLogin(argv) {
         console.log(`\u{1F4C1} Credentials saved to ${CREDENTIALS_FILE}`);
         await chooseWorkspace(creds);
         await maybeConfigureTimezone();
+        await offerSkillsAfterLogin(argv);
         return;
       }
       if (data.error === "authorization_pending") {
@@ -910,7 +1244,7 @@ async function authSignup(argv) {
         });
         return;
       }
-      code = (await ask("Code from the e-mail: ")).trim();
+      code = (await ask2("Code from the e-mail: ")).trim();
       if (!code) {
         console.error("\u274C No code given. Run the command again with --code <code>.");
         process.exit(1);
@@ -926,7 +1260,7 @@ async function authSignup(argv) {
     status(`  Privacy notice:    ${PRIVACY_URL}`);
     let accepted = !!argv.acceptTerms;
     if (!accepted && interactive) {
-      const answer = (await ask("Do you agree to both? [y/N] ")).trim().toLowerCase();
+      const answer = (await ask2("Do you agree to both? [y/N] ")).trim().toLowerCase();
       accepted = answer === "y" || answer === "yes" || answer === "i" || answer === "igen";
     }
     if (!accepted) {
@@ -1150,7 +1484,7 @@ function getConfig() {
 }
 
 // src/commands/posts.ts
-var import_fs3 = require("fs");
+var import_fs4 = require("fs");
 var pairContentsWithMedia = (argv) => {
   const read = (token, next, long, short) => {
     if (token === `--${long}` || token === `-${short}`) {
@@ -1240,11 +1574,11 @@ async function createPost(args) {
   if (args.json) {
     try {
       const jsonPath = args.json;
-      if (!(0, import_fs3.existsSync)(jsonPath)) {
+      if (!(0, import_fs4.existsSync)(jsonPath)) {
         console.error(`\u274C JSON file not found: ${jsonPath}`);
         process.exit(1);
       }
-      const jsonContent = (0, import_fs3.readFileSync)(jsonPath, "utf-8");
+      const jsonContent = (0, import_fs4.readFileSync)(jsonPath, "utf-8");
       postData = JSON.parse(jsonContent);
     } catch (error) {
       console.error(`\u274C Failed to parse JSON file: ${error.message}`);
@@ -1490,18 +1824,18 @@ async function getPostAnalytics(args) {
 }
 
 // src/commands/upload.ts
-var import_fs4 = require("fs");
-var import_path3 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 async function uploadFile(args) {
   const config = getConfig();
   const api = new PostemiAPI(config);
-  if (!(0, import_fs4.existsSync)(args.file)) {
+  if (!(0, import_fs5.existsSync)(args.file)) {
     console.error(`\u274C File not found: ${args.file}`);
     process.exit(1);
   }
   try {
-    const fileBuffer = (0, import_fs4.readFileSync)(args.file);
-    const filename = (0, import_path3.basename)(args.file) || "file";
+    const fileBuffer = (0, import_fs5.readFileSync)(args.file);
+    const filename = (0, import_path5.basename)(args.file) || "file";
     const res = await api.upload(fileBuffer, filename);
     status("\u2705 File uploaded successfully!");
     result(res);
@@ -2121,6 +2455,28 @@ async function billingManage(args) {
     });
   },
   billingManage
+).command(
+  "skills <command>",
+  `Optional agent skills: install them into Claude Code, Codex, Cursor or Grok Build`,
+  (yargs2) => {
+    const target = (y) => y.positional("skills", {
+      describe: "writing (with templates), growth, all, or core",
+      type: "string",
+      array: true
+    }).option("agent", {
+      describe: "Only these agents: claude, codex, cursor, grok, or all (skips the question)",
+      type: "string",
+      array: true
+    }).option("yes", { alias: "y", describe: "Ask nothing; use every agent found", type: "boolean", default: false }).option("json", { describe: "Run as an agent or script: never ask", type: "boolean", default: false });
+    return yargs2.command("list", "Show the core and optional skills, and where each is installed", {}, skillsList).command(
+      "add [skills..]",
+      "Install skills (writing, growth, all); asks which when you name none",
+      (y) => target(y).example("$0 skills add writing", "Writing and template skills, plus the core skill").example("$0 skills add all --agent claude --yes", "Both optional skills, Claude Code only, no questions"),
+      skillsAdd
+    ).command("remove [skills..]", "Remove installed skills (writing, growth, all, core)", target, skillsRemove).demandCommand(1, `Use: ${BRAND.cli} skills list | add | remove`);
+  },
+  () => {
+  }
 ).command(
   "config:set <key> <value>",
   `Save a CLI setting to ~/${BRAND.configDirName}/config.json`,
@@ -2154,6 +2510,10 @@ async function billingManage(args) {
     return yargs2.option("auth-server", {
       describe: `Auth server URL (default: ${BRAND.defaultApiUrl})`,
       type: "string"
+    }).option("json", {
+      describe: "Run as an agent or script: ask no setup questions after the login",
+      type: "boolean",
+      default: false
     }).example(
       "$0 auth:login",
       "Login via OAuth2 device flow"