@skyf0xx/hedgehog 6.1.8 → 6.2.0

package/bin/cli.mjs

@@ -64,7 +64,12 @@ import {
   shouldPromptForStar,
   recordStarAnswer,
   formatStarPrompt,
+  shouldPromptForShowcase,
+  recordShowcaseAnswer,
+  formatShowcasePrompt,
+  postShowcase,
   REPO_URL,
+  SHOWCASE_REPO_URL,
 } from '../src/db/community.mjs';
 import { rebuildDb } from '../src/db/rebuild.mjs';
 import {
@@ -628,6 +633,9 @@ ${bold('Usage')}
   npx @skyf0xx/hedgehog decision list [<task-id>]     list declared decisions, oldest first
   npx @skyf0xx/hedgehog db migrate                bring the graph's schema up to the latest version
   npx @skyf0xx/hedgehog community star --answer <a>   record the star prompt's answer
+  npx @skyf0xx/hedgehog community showcase --repo <url> [--description <text>]
+                                                   share what you built to the public showcase
+  npx @skyf0xx/hedgehog community showcase --answer later|dismissed   defer or decline showcasing
   npx @skyf0xx/hedgehog --help
 
 Available cores: ${cores.join(', ')} (${bold('cores list')} for what each one is for)
@@ -2233,10 +2241,21 @@ async function verifyCommand(args) {
 
   // Fires once per project — see community.mjs. Deliberately last: after
   // the gate's own output, not before it.
-  if (await shouldPromptForStar(DEST_ROOT, { intentComplete: result.intentComplete })) {
+  const starJustShown = await shouldPromptForStar(DEST_ROOT, { intentComplete: result.intentComplete });
+  if (starJustShown) {
     console.log(formatStarPrompt());
     console.log('');
   }
+
+  // Independent second ask, gated on the star question already having a
+  // pre-existing answer or deferral — never on the same verify call that
+  // just showed the star prompt for the first time. See
+  // shouldPromptForShowcase for why `starJustShown` has to come from
+  // here rather than being re-derived from state.
+  if (await shouldPromptForShowcase(DEST_ROOT, { intentComplete: result.intentComplete, starJustShown })) {
+    console.log(formatShowcasePrompt());
+    console.log('');
+  }
 }
 
 // Prints the full task packet for each task in `tasks`, read back from
@@ -3836,20 +3855,34 @@ async function decisionCommand(args) {
   process.exitCode = 1;
 }
 
-// `hedgehog community star --answer starred|later|dismissed` — records
-// the star prompt's answer. No build graph or core needed: this is
-// project state about a question asked, not about the build.
+const COMMUNITY_USAGE = [
+  'hedgehog community star --answer starred|later|dismissed',
+  '   or: hedgehog community showcase --repo <url> [--description <text>]',
+  '   or: hedgehog community showcase --answer later|dismissed',
+].join('\n');
+
+// `hedgehog community star --answer starred|later|dismissed` and
+// `hedgehog community showcase ...` — record each prompt's answer. No
+// build graph or core needed: this is project state about questions
+// asked, not about the build.
 async function communityCommand(args) {
   const sub = args[0];
 
-  if (sub !== 'star') {
-    console.error(
-      `${red('Unknown community subcommand:')} ${sub ?? '(none)'}\n\nUsage: hedgehog community star --answer starred|later|dismissed\n`,
-    );
-    process.exitCode = 1;
+  if (sub === 'star') {
+    await communityStarCommand(args.slice(1));
+    return;
+  }
+
+  if (sub === 'showcase') {
+    await communityShowcaseCommand(args.slice(1));
     return;
   }
 
+  console.error(`${red('Unknown community subcommand:')} ${sub ?? '(none)'}\n\nUsage: ${COMMUNITY_USAGE}\n`);
+  process.exitCode = 1;
+}
+
+async function communityStarCommand(args) {
   const answerIdx = args.indexOf('--answer');
   const answer = answerIdx !== -1 ? args[answerIdx + 1] : undefined;
   const ANSWERS = ['starred', 'later', 'dismissed'];
@@ -3872,6 +3905,61 @@ async function communityCommand(args) {
   }
 }
 
+// `hedgehog community showcase --repo <url> [--description <text>]`
+// records and submits a showcase entry; `hedgehog community showcase
+// --answer later|dismissed` records a deferral or decline with nothing
+// to submit. `--repo` and `--answer` are mutually exclusive ways of
+// answering the same prompt, mirroring the star command's single
+// `--answer` flag but split in two because only this branch has a
+// network call and a second, optional flag (`--description`).
+async function communityShowcaseCommand(args) {
+  const repoIdx = args.indexOf('--repo');
+  const repoUrl = repoIdx !== -1 ? args[repoIdx + 1] : undefined;
+  const descIdx = args.indexOf('--description');
+  const description = descIdx !== -1 ? args[descIdx + 1] : undefined;
+  const answerIdx = args.indexOf('--answer');
+  const answer = answerIdx !== -1 ? args[answerIdx + 1] : undefined;
+
+  if (repoUrl) {
+    // Courtesy check only — well-formed and http(s). The relay (#365) is
+    // the real validation authority; this just catches an obvious typo
+    // before spending a network round trip on it.
+    let parsed;
+    try {
+      parsed = new URL(repoUrl);
+    } catch {
+      parsed = null;
+    }
+    if (!parsed || !['http:', 'https:'].includes(parsed.protocol)) {
+      console.error(`${red('Usage:')} hedgehog community showcase --repo <http(s) url> [--description <text>]\n`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const core = (await installedCore(DEST_ROOT))?.name;
+    await postShowcase({ repoUrl, core, description });
+    await recordShowcaseAnswer(DEST_ROOT, 'shared', { repoUrl, core, description });
+
+    console.log(`  ${green('shared')}  ${dim(SHOWCASE_REPO_URL)}`);
+    return;
+  }
+
+  const ANSWERS = ['later', 'dismissed'];
+  if (!ANSWERS.includes(answer)) {
+    console.error(`${red('Usage:')} ${COMMUNITY_USAGE}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  await recordShowcaseAnswer(DEST_ROOT, answer);
+
+  if (answer === 'later') {
+    console.log(`  ${dim('deferred')}  ${dim('asked again after about a week of building')}`);
+  } else {
+    console.log(`  ${dim('dismissed')}  ${dim('not asked again in this project')}`);
+  }
+}
+
 // `hedgehog cores list` — every core this release can install, the
 // package that ships it, and which of its versions are already extracted
 // locally. The prose each entry carries is what planner reads in Phase 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyf0xx/hedgehog",
-  "version": "6.1.8",
+  "version": "6.2.0",
   "description": "Install the Hedgehog build discipline (agents + skills) into a repo, for Claude Code, Cursor, or Gemini CLI.",
   "type": "module",
   "repository": {

package/src/db/community.mjs

@@ -1,21 +1,33 @@
-// The one thing Hedgehog asks of the person using it: a prompt to star
-// and watch the repo, raised by `hedgehog verify` at the first intent to
-// close every one of its layers — the first point the user has seen
-// planned work come out complete rather than merely generated.
+// The two things Hedgehog asks of the person using it, both raised by
+// `hedgehog verify` at the first intent to close every one of its layers
+// — the first point the user has seen planned work come out complete
+// rather than merely generated:
 //
-//   1. It asks once. `starred` and `dismissed` end it permanently;
-//      `later` re-arms after a cooldown rather than repeating. Being
-//      shown at all defers it on the same cooldown, so a prompt the user
-//      talks past costs one interruption rather than one per intent.
-//   2. It stops the build. The instruction block tells the agent to hold
-//      the Loop until the user answers, unlike every other notice this
-//      CLI prints, which is advisory.
-//   3. It's framed as what the user gets: watching releases is how a user
-//      finds out their installed payload is behind; starring helps the
-//      project. Both stated plainly.
+//   1. STAR — a prompt to star and watch the repo.
+//   2. SHOWCASE — a prompt to share what got built: a repo URL, the
+//      installed core's name, and an optional description, POSTed to a
+//      public showcase relay. Independent of the star ask, and fires
+//      only after the star question has already been answered in the
+//      same verify pass — never on the same call as an unanswered star
+//      prompt, and never before it.
 //
-// State lives in `.hedgehog/community.json`, per project rather than in
-// `~/.hedgehog/`.
+// Both share one shape:
+//
+//   1. Each asks once. A terminal answer ends it permanently; `later`
+//      re-arms after a cooldown rather than repeating. Being shown at
+//      all defers it on the same cooldown, so a prompt the user talks
+//      past costs one interruption rather than one per intent.
+//   2. Each stops the build. The instruction block tells the agent to
+//      hold the Loop until the user answers, unlike every other notice
+//      this CLI prints, which is advisory.
+//   3. Each is framed as what the user gets, or plainly as what leaves
+//      the project: the star ask states that watching releases is how a
+//      user finds out their installed payload is behind, and starring
+//      helps the project; the showcase ask states plainly that what's
+//      submitted is a public data point, not private telemetry.
+//
+// State for both lives in `.hedgehog/community.json`, per project rather
+// than in `~/.hedgehog/`.
 
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
@@ -27,16 +39,28 @@ export const COMMUNITY_PATH = '.hedgehog/community.json';
 
 export const REPO_URL = 'https://github.com/skyf0xx/hedgehog';
 
-// How long "later" (and an unanswered "shown") defers for.
+// The public showcase repo submissions are committed into — named here
+// so formatShowcasePrompt can point at it directly rather than making
+// the user go find it.
+export const SHOWCASE_REPO_URL = 'https://github.com/skyf0xx/hedgehog-showcase';
+
+// Placeholder until #365 (the Cloudflare Worker relay) ships and hands
+// over the real endpoint. Requests here fail closed (see
+// postShowcase below) so a stale or unreachable placeholder is silently
+// a no-op rather than a build-blocking error.
+const SHOWCASE_RELAY_URL = 'https://showcase-relay.hedgehog.build/submit';
+
+// How long "later" (and an unanswered "shown") defers for, shared by
+// both prompts — one cooldown constant, not one per prompt.
 const LATER_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000;
 
-// `starPrompt` is one of:
+// Both `starPrompt` and `showcasePrompt` are one of:
 //   (unset)     never shown
 //   shown       displayed but not answered — deferred
 //   later       user asked to be reminded — deferred
-//   starred     terminal
+//   starred* / shared*   terminal (see each prompt's own answer set)
 //   dismissed   terminal
-const TERMINAL = new Set(['starred', 'dismissed']);
+const TERMINAL = new Set(['starred', 'shared', 'dismissed']);
 
 async function readState(root) {
   try {
@@ -128,3 +152,128 @@ export function formatStarPrompt() {
     '  and carry on with the build.',
   ].join('\n');
 }
+
+/**
+ * Whether the showcase prompt should fire now. Same terminal/cooldown
+ * state machine as shouldPromptForStar, keyed on its own `showcasePrompt`
+ * field — but gated first on the star question already having a
+ * pre-existing answer or deferral (from a *prior* verify pass), never on
+ * the same call that just showed the star prompt for the first time.
+ *
+ * `starJustShown` is the caller's own shouldPromptForStar return value
+ * from this same verify call: shouldPromptForStar's side effect writes
+ * `starPrompt: 'shown'` the instant it fires, so reading `starPrompt`
+ * back out of state right after can't otherwise tell "already shown
+ * before this call" apart from "shown just now, this call, unanswered"
+ * — both read as the string 'shown'. Passing the caller's own boolean is
+ * the one unambiguous signal for that distinction; the caller already
+ * has it for free as the value it just branched on to print the star
+ * prompt.
+ */
+export async function shouldPromptForShowcase(root, { intentComplete, starJustShown = false }) {
+  if (!intentComplete) return false;
+  if (starJustShown) return false;
+
+  const { starPrompt, showcasePrompt, showcaseDeferredAt } = await readState(root);
+
+  // Unset means the star prompt has never been shown at all — never
+  // before it, whether or not it's been answered yet.
+  if (!starPrompt) return false;
+
+  if (TERMINAL.has(showcasePrompt)) return false;
+
+  if (showcasePrompt === 'later' || showcasePrompt === 'shown') {
+    const since = Date.now() - Date.parse(showcaseDeferredAt ?? '');
+    if (!Number.isFinite(since) || since < LATER_COOLDOWN_MS) return false;
+  }
+
+  // Recorded before returning, so an unanswered display defers itself
+  // rather than re-firing at every later intent completion.
+  await writeState(root, { showcasePrompt: 'shown', showcaseDeferredAt: new Date().toISOString() });
+
+  return true;
+}
+
+/**
+ * Record the user's answer. `answer` is 'shared' | 'later' | 'dismissed'.
+ * `submission` (repoUrl, core, description) is attached only when
+ * `answer` is 'shared', for anyone reading community.json back later.
+ */
+export async function recordShowcaseAnswer(root, answer, submission) {
+  const patch = { showcasePrompt: answer, showcaseAnsweredAt: new Date().toISOString() };
+  if (answer === 'later') patch.showcaseDeferredAt = new Date().toISOString();
+  if (answer === 'shared' && submission) patch.showcaseSubmission = submission;
+  await writeState(root, patch);
+}
+
+/** The prompt itself, addressed to the agent — parallel to
+ * formatStarPrompt. Kept visually and textually distinct from the star
+ * ask: a separate heading, a separate command, and an explicit statement
+ * that this is public, optional, and unrelated to closing the intent. */
+export function formatShowcasePrompt() {
+  return [
+    'SHOWCASE PROMPT  — a separate, optional question. Ask the user this now,',
+    '  then STOP.',
+    '',
+    '  This is unrelated to the star question and does not affect whether the',
+    '  intent is done — it is already done. Put this question to the user, wait',
+    '  for their answer, and do not start the next task, claim, or any other',
+    '  work until they have answered. Ask it once. It will not be asked again.',
+    '',
+    '  Say, in your own words:',
+    '',
+    '    Want to share what you built? Hedgehog keeps a public showcase of',
+    `    projects built with it: ${SHOWCASE_REPO_URL}`,
+    '    Sharing submits your repo URL, the core you built with, and an',
+    '    optional description. This is a public data point, committed into',
+    '    that public repo — not private telemetry, and entirely optional.',
+    '',
+    '  Then offer exactly three options and wait:',
+    '',
+    '    1. Share it        — ask for a repo URL and an optional description',
+    "    2. Later           — ask again after about a week of building",
+    "    3. Don't show again — never ask in this project again",
+    '',
+    '  On option 1, ask for the repo URL (and, optionally, a short description),',
+    '  then record and submit it:',
+    '',
+    '    hedgehog community showcase --repo <url> [--description "<text>"]',
+    '',
+    '  On option 2 or 3, record the answer without submitting anything:',
+    '',
+    '    hedgehog community showcase --answer later|dismissed',
+    '',
+    '  Never re-ask after recording, and never pressure a decline — option 3',
+    '  is a legitimate answer and the correct response to it is to record it',
+    '  and carry on with the build.',
+  ].join('\n');
+}
+
+/**
+ * POST a showcase submission to the relay. Follows fetchLatest's
+ * (src/hosts/version.mjs) fail-silent convention exactly: a short abort
+ * timeout, catch-all, never throws, never blocks verify or the CLI. On
+ * any failure — unreachable host, timeout, non-2xx, relay not yet
+ * provisioned — this silently drops the submission. No retry, no stored
+ * pending state: the relay is the system of record once it exists (see
+ * #365), not this CLI.
+ */
+export async function postShowcase({ repoUrl, core, description }) {
+  try {
+    const body = JSON.stringify({
+      repoUrl,
+      core,
+      ...(description ? { description } : {}),
+      timestamp: new Date().toISOString(),
+    });
+    await fetch(SHOWCASE_RELAY_URL, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body,
+      signal: AbortSignal.timeout(1500),
+    });
+  } catch {
+    // Unreachable, timed out, or the relay doesn't exist yet (#365) —
+    // all the same outcome from here: the submission is dropped.
+  }
+}

package/src/hosts/gemini/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgehog",
-  "version": "6.1.8",
+  "version": "6.2.0",
   "description": "Hedgehog build discipline: ordered, tested, verified build steps.",
   "contextFileName": "GEMINI.md"
 }