intentdocs 0.8.0

package/dist/chunk-IKF3ZLHK.js

@@ -0,0 +1,621 @@
+import {
+  writeStoryContext
+} from "./chunk-6FGYJ3W2.js";
+import {
+  choose,
+  closePrompt
+} from "./chunk-WPVDURTJ.js";
+import {
+  apiFetch,
+  getContext,
+  listStories
+} from "./chunk-6XKB6RTU.js";
+import {
+  hasConfig,
+  requireConfig
+} from "./chunk-ICOMMHKG.js";
+import {
+  getAuth,
+  requireAuth
+} from "./chunk-PCNDP5SX.js";
+
+// src/commands/setup.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2, readFileSync, unlinkSync } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir } from "os";
+
+// src/commands/sync.ts
+import { writeFileSync, readdirSync, existsSync, statSync } from "fs";
+import { join } from "path";
+
+// src/lib/analytics.ts
+import { PostHog } from "posthog-node";
+var client = null;
+function getClient() {
+  if (client) return client;
+  const auth = getAuth();
+  if (!auth?.posthogKey) return null;
+  client = new PostHog(auth.posthogKey, {
+    host: auth.posthogHost ?? "https://eu.i.posthog.com",
+    flushAt: 1,
+    flushInterval: 0
+  });
+  return client;
+}
+function getDistinctId() {
+  return getAuth()?.userId ?? null;
+}
+function captureCli(event, properties, groups) {
+  const posthog = getClient();
+  const distinctId = getDistinctId();
+  if (!posthog || !distinctId) return;
+  posthog.capture({
+    distinctId,
+    event,
+    properties: {
+      ...properties,
+      ...groups?.project ? { project_id: groups.project } : {}
+    },
+    ...groups ? { groups } : {}
+  });
+}
+async function shutdownCliAnalytics() {
+  if (client) await client.shutdown();
+}
+
+// src/commands/sync.ts
+async function syncContextFile(config) {
+  const res = await apiFetch(config, "/context-file?format=claude");
+  const { content } = await res.json();
+  const cwd = process.cwd();
+  const claudeDir = join(cwd, ".claude");
+  let filePath;
+  if (existsSync(claudeDir)) {
+    filePath = join(claudeDir, "CLAUDE.md");
+  } else {
+    filePath = join(cwd, "CLAUDE.md");
+  }
+  writeFileSync(filePath, content, "utf-8");
+  const rel = filePath.replace(cwd + "/", "");
+  console.log(`\u2713 ${rel} generated from intentdocs project`);
+}
+async function sync(opts) {
+  const config = requireConfig();
+  if (opts?.context) {
+    console.log("Refreshing context file from intentdocs...");
+    try {
+      await syncContextFile(config);
+      captureCli(
+        "claude_md_snapshot_created",
+        { trigger: "stc_sync_context" },
+        { project: config.projectId }
+      );
+      await shutdownCliAnalytics();
+    } catch (err) {
+      console.error("\u2717 Failed to refresh context file:", err.message);
+      process.exit(1);
+    }
+    return;
+  }
+  console.log("Syncing with intentdocs...");
+  const [md, data] = await Promise.all([
+    getContext(config),
+    listStories(config)
+  ]);
+  writeFileSync(join(process.cwd(), "INTENT.md"), md);
+  const { summary } = data;
+  const pct = summary.total > 0 ? Math.round(summary.done / summary.total * 100) : 0;
+  console.log(`\u2713 INTENT.md updated  (${summary.done}/${summary.total} done, ${pct}%)`);
+  apiFetch(config, "/activity", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      event_type: "sync",
+      summary: `Synced story map \u2014 ${summary.done}/${summary.total} stories done (${pct}%)`,
+      source: "cli"
+    })
+  }).catch(() => void 0);
+  const contextDir = join(process.cwd(), ".intent", "stories");
+  if (!existsSync(contextDir)) return;
+  const localFiles = readdirSync(contextDir).filter((f) => f.endsWith(".md"));
+  if (localFiles.length === 0) return;
+  const storyMap = new Map(data.stories.map((s) => [s.id, s]));
+  let refreshed = 0;
+  let stale = 0;
+  for (const filename of localFiles) {
+    const storyId = filename.replace(".md", "");
+    const story = storyMap.get(storyId);
+    if (!story) {
+      stale++;
+      continue;
+    }
+    writeStoryContext(story);
+    refreshed++;
+  }
+  if (refreshed > 0 || stale > 0) {
+    console.log(`\u2713 .intent/stories/ refreshed (${refreshed} updated${stale > 0 ? `, ${stale} orphaned` : ""})`);
+    if (stale > 0) {
+      console.log(`  \u26A0  ${stale} context file(s) have no matching story \u2014 they may have been deleted in the UI.`);
+    }
+  }
+  const specPath = join(process.cwd(), "INTENT.md");
+  const specBytes = existsSync(specPath) ? statSync(specPath).size : 0;
+  captureCli(
+    "harness_health_computed",
+    {
+      completeness_pct: pct,
+      stories_total: summary.total,
+      stories_done: summary.done,
+      spec_bytes: specBytes,
+      context_files_refreshed: refreshed
+    },
+    { project: config.projectId }
+  );
+  await shutdownCliAnalytics();
+}
+
+// src/commands/setup.ts
+async function setup() {
+  requireAuth();
+  if (!hasConfig()) {
+    console.log("  Not connected to a project. Run `intent init` first.");
+    closePrompt();
+    return;
+  }
+  const config = requireConfig();
+  const idx = await choose("  Which AI tool do you want to configure?", [
+    "Claude Code",
+    "Cursor",
+    "Both"
+  ]);
+  const tools = idx === 0 ? ["claude"] : idx === 1 ? ["cursor"] : ["claude", "cursor"];
+  for (const tool of tools) {
+    if (tool === "claude") setupClaudeCode(config.syncToken);
+    if (tool === "cursor") setupCursor(config.syncToken);
+  }
+  try {
+    await syncContextFile(config);
+  } catch {
+    console.log("  \u26A0 Could not fetch project context (run `intent sync --context` to retry)");
+  }
+  generateAgentDocs();
+  console.log(`
+  \u2705 Agent configuration complete!
+
+  Your AI tool now has:
+    \u2022 Full project context: instructions, scope, decisions, examples, tools, guardrails
+    \u2022 Slash commands for the full development workflow
+    \u2022 Agent guides for implementing, reviewing, and documenting features
+
+  Slash commands (inside Claude Code / Cursor):
+    /intent-next        Pick up the next story
+    /intent-implement   Full implementation playbook
+    /intent-review      Review against acceptance criteria
+    /intent-done        Mark a story done + log a decision
+    /intent-propose     Propose a new change
+    /intent-sync        Refresh context from intentdocs
+
+  Terminal commands:
+    intent next              Next priority story
+    intent done <id>         Mark done + log decision/lesson
+    intent decide            Log an architectural decision
+    intent example           Log a reference pattern
+    intent sync              Refresh INTENT.md
+    intent sync --context    Regenerate CLAUDE.md from intentdocs
+    intent status            Recent activity
+  `);
+  closePrompt();
+}
+function setupClaudeCode(syncToken) {
+  const cwd = process.cwd();
+  const claudeMdPath = join2(cwd, "CLAUDE.md");
+  const claudeBlock = `
+# intentdocs Integration
+
+This project is connected to a intentdocs story map.
+Run \`intent sync --context\` to generate the full CLAUDE.md with your project's instructions,
+story map, decisions, examples, tools, and guardrails.
+
+## Quick reference
+
+| Command | What it does |
+|---|---|
+| \`intent next\` | Pick up the next priority story |
+| \`intent done <id>\` | Mark a story done + log a decision |
+| \`intent decide\` | Log an architectural or product decision |
+| \`intent example\` | Log a reference pattern for this codebase |
+| \`intent sync\` | Refresh story map + INTENT.md |
+| \`intent sync --context\` | Regenerate this file from intentdocs |
+| \`intent status\` | Show recent activity |
+`;
+  if (existsSync2(claudeMdPath)) {
+    const existing = readFileSync(claudeMdPath, "utf-8");
+    if (!existing.includes("intentdocs Integration")) {
+      writeFileSync2(claudeMdPath, existing + "\n" + claudeBlock);
+      console.log("  \u2713 Updated CLAUDE.md with intentdocs agent workflow");
+    } else {
+      console.log("  \u2713 CLAUDE.md already configured");
+    }
+  } else {
+    writeFileSync2(claudeMdPath, claudeBlock.trim() + "\n");
+    console.log("  \u2713 Created CLAUDE.md with intentdocs agent workflow");
+  }
+  const commandsDir = join2(cwd, ".claude", "commands");
+  if (!existsSync2(commandsDir)) mkdirSync(commandsDir, { recursive: true });
+  const oldPbCommands = ["pb-next", "pb-implement", "pb-review", "pb-document", "pb-test", "pb-status", "pb-done", "pb-sync", "pb-propose", "pb-context"];
+  for (const name of oldPbCommands) {
+    const oldPath = join2(commandsDir, name + ".md");
+    if (existsSync2(oldPath)) {
+      unlinkSync(oldPath);
+    }
+  }
+  writeFileSync2(
+    join2(commandsDir, "intent-next.md"),
+    `# Pick up the next story
+
+1. Run \`intent next\` to get the highest-priority story
+2. Read the acceptance criteria carefully \u2014 these define "done"
+3. Check ARCHITECTURE.md for relevant technical decisions
+4. Read CONVENTIONS.md for coding patterns to follow
+5. Outline your implementation plan before writing code
+6. Ask for confirmation before proceeding
+`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-implement.md"),
+    `# Implement a story
+
+## Context to load first
+1. Read CLAUDE.md \u2014 your full project harness (instructions, decisions, examples, tools, guardrails)
+2. Run \`intent next\` if you don't have a story yet
+3. Review the "Done when" acceptance criteria \u2014 each one carries a priority
+   (\`must\`/\`should\`) and a verification method: \`[executable]\` gives you a
+   \`check:\` command to run, \`[self-check]\`/\`[visual]\`/\`[founder]\` give you
+   a \`check:\` question to answer by inspecting code/output
+
+## Process
+4. Plan: which files change? Check the Reference Patterns in CLAUDE.md first.
+5. Implement \u2014 stay inside the Guardrails section
+6. Write or update tests
+
+## The acceptance-criteria loop
+7. Evaluate every criterion using its verification method: run the \`check:\`
+   command for \`[executable]\` criteria, answer the \`check:\` question for
+   the others.
+8. Report every result via the \`report_criteria\` MCP tool
+   (\`{ story_id, results: [{ criterion_id, status: pass|fail|blocked, detail }] }\`).
+9. For any failing \`must\` criterion: fix it and re-check. If the *same*
+   \`must\` criterion fails 3 times, call \`raise_blocker\` with what you
+   attempted, what's failing, and the single decision the founder needs to
+   make \u2014 then stop working on this story.
+10. Never call \`mark_done\` (or \`intent done\`) while a \`must\` criterion is
+    still failing or has never been reported \u2014 both will warn you and
+    require an explicit override if you try.
+
+## Write back to intentdocs
+11. Add implementation notes:
+    \`intent note <story-id> "How this was implemented"\`
+12. Log decisions: \`intent decide "Title" -d "What and why" -c architecture\`
+13. Log useful patterns: \`intent example\`
+14. If you discovered new requirements:
+    \`intent add "title" --activity "Activity" --priority should\`
+15. Mark done: \`intent done <story-id>\`
+16. Commit: \`git commit -m "feat: description [SC-<id>]"\`
+
+## Rules
+- Don't over-engineer. Build exactly what the acceptance criteria describe.
+- Always log significant decisions \u2014 future developers need context.
+- Follow patterns in CONVENTIONS.md
+- Never mark a story done with a failing or unreported \`must\` criterion.
+`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-review.md"),
+    `# Review against acceptance criteria
+
+1. Identify the story being worked on
+2. For each acceptance criterion:
+   - Does the implementation satisfy it? (yes/no/partial)
+   - If partial, what's missing?
+3. Check for: edge cases, error handling, accessibility, security
+4. Summarise: what's done, what needs work, any concerns
+`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-document.md"),
+    `# Document a feature
+
+1. Check which story was just completed
+2. Read INTENT.md for product context
+3. Write a brief markdown doc explaining:
+   - What was built and why
+   - How it works (architecture-level)
+   - Decisions made and trade-offs
+   - How to test it manually
+4. Log decisions to intentdocs:
+   \`intent decide "Title" -d "Description" -c architecture\`
+5. Add implementation notes:
+   \`intent note <story-id> "Summary of how it works"\`
+6. Update ARCHITECTURE.md if needed
+7. Update CONVENTIONS.md if new patterns were introduced
+`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-test.md"),
+    `# Write tests for a story
+
+1. Get the story details: \`intent next\` or provided story ID
+2. Each acceptance criterion becomes at least one test
+3. Also consider: error cases, boundary conditions, integration points
+4. Follow testing patterns in CONVENTIONS.md
+5. Run the tests to verify they pass
+`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-status.md"),
+    `Run \`intent status\` and \`intent stories --filter todo\` to show current progress and remaining backlog. Summarise what's done and what's left.`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-done.md"),
+    `Ask which story was just completed, then run \`intent done <id>\`.
+\`intent done\` prints the acceptance-criteria table first. If any \`must\` criterion is still failing or was
+never reported via \`report_criteria\`, it will list them and ask "Mark done anyway?" \u2014 only confirm that
+if the founder explicitly wants to override; otherwise go fix the failing criterion and re-run \`intent done\`.
+The CLI will prompt for an optional decision or lesson learned \u2014 encourage the user to capture it.
+Also ask if there are implementation notes to add: \`intent note <id> "..."\`
+Both decisions and notes flow back to the project page on intentdocs.com.`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-sync.md"),
+    `# Refresh context from intentdocs
+
+## Refresh story map summary
+Run \`intent sync\` \u2014 updates INTENT.md with the latest stories and their status.
+
+## Regenerate the full CLAUDE.md harness
+Run \`intent sync --context\` \u2014 rebuilds CLAUDE.md from your project page, pulling in:
+- Role & Goals (Instructions section)
+- Scope (all story maps + story counts)
+- Decisions & Memory (last 10 decisions)
+- Reference Patterns (Examples you've logged)
+- Tools & Stack (structured tool registry + MCP config)
+- Guardrails (hard constraints)
+
+Run \`intent sync --context\` after updating any section on intentdocs.com.`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-propose.md"),
+    `# Propose a new change
+
+Use this when you want to plan a new feature, improvement, or fix before writing code.
+intentdocs stores the source of truth in your online story map \u2014 this command creates
+stories there AND saves a local spec for the AI to reference during implementation.
+
+## Process
+1. Ask the user: "What do you want to build or change? Describe the problem and the solution."
+2. Help them break it into 2-5 stories with clear acceptance criteria (each AC is testable)
+3. Run: \`intent propose <change-name>\`
+   - The CLI will guide through: problem, solution, activity, priority, stories + ACs
+   - Stories are created in the live story map at intentdocs.com
+   - A local spec is saved to \`intent-changes/<name>/proposal.md\`
+4. Once done: \`intent sync\` to pull the new stories into INTENT.md
+5. Run \`intent next\` to start implementing
+
+## Tips
+- Change names should be kebab-case: add-dark-mode, fix-auth-flow, onboarding-revamp
+- Keep stories small \u2014 one story = one deployable increment
+- Write ACs as testable outcomes: "Given X, when Y, then Z" or "User can..."
+- If the change is already defined in the UI, just run \`intent sync\` instead
+`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-context.md"),
+    `# Load current story context
+
+Use this to focus on a single story without loading the full story map.
+
+## When to use
+- At the start of a coding session for a specific story
+- When switching between stories mid-session
+- When you need a clean, focused view of ACs and notes
+
+## Process
+1. Run \`intent next\` to get the active story \u2014 this automatically writes the context file to \`.intent/stories/<id>.md\`
+2. Read that file \u2014 it contains: title, user story, acceptance criteria (as checkboxes), notes, and space for relevant files
+3. Use it as your working document throughout implementation:
+   - Check off ACs as you satisfy them
+   - Add file paths under "Relevant files" as you discover them
+   - Run \`intent note <id> "..."\` to log notes (updates both remote map and local file)
+4. When all ACs are checked: \`intent done <id>\`
+
+## If you already know the story ID
+The file is at \`.intent/stories/<full-story-id>.md\` \u2014 read it directly.
+`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-decide.md"),
+    `# Log an architectural or product decision
+
+Use this when you've made a decision that future agents (or teammates) should know about.
+
+Run \`intent decide\` \u2014 the CLI will prompt for:
+- Title: short, specific description of the decision
+- Description: what was decided and why (include trade-offs considered)
+- Category: architecture / product / technical / trade-off
+
+Decisions appear in the Memory section of the project page at intentdocs.com
+and are included in CLAUDE.md the next time you run \`intent sync --context\`.
+
+Good decisions to log:
+- "Chose X over Y because..."
+- "Decided not to do Z because..."
+- "This pattern is used throughout because..."`
+  );
+  writeFileSync2(
+    join2(commandsDir, "intent-example.md"),
+    `# Log a reference pattern for this codebase
+
+Use this when you've written code that represents the right way to do something in this project.
+
+Run \`intent example\` \u2014 the CLI will prompt for:
+- Title: what the pattern is
+- Description: when to use it
+- Language: typescript / python / bash / other
+- Before code: the old way (optional)
+- After code: the correct pattern to follow
+
+Examples appear in the Knowledge > Examples section of the project page
+and are included in CLAUDE.md as Reference Patterns the next time you run \`intent sync --context\`.`
+  );
+  console.log("  \u2713 Created slash commands: /intent-propose, /intent-next, /intent-implement, /intent-review, /intent-document, /intent-test, /intent-status, /intent-done, /intent-sync, /intent-context, /intent-decide, /intent-example");
+  registerMcpWithClaudeCode();
+}
+function registerMcpWithClaudeCode() {
+  const settingsPath = join2(homedir(), ".claude", "settings.json");
+  let settings = {};
+  if (existsSync2(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  const servers = settings.mcpServers ?? {};
+  servers.intent = { command: "npx", args: ["intentdocs", "mcp"] };
+  settings.mcpServers = servers;
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  console.log("  \u2713 Registered MCP server in ~/.claude/settings.json \u2014 restart Claude Code to activate");
+}
+function setupCursor(syncToken) {
+  const cwd = process.cwd();
+  const cursorRulesPath = join2(cwd, ".cursorrules");
+  const cursorBlock = `
+# intentdocs Integration
+
+## Context files
+1. **INTENT.md** \u2014 product story map with personas, stories, acceptance criteria
+2. **ARCHITECTURE.md** \u2014 technical decisions and system structure
+3. **CONVENTIONS.md** \u2014 coding patterns, naming, file structure
+
+## Workflow
+- Next story: \`intent next\`
+- Mark done: \`intent done <id>\`
+- Add notes: \`intent note <id> "..."\`
+- Log decisions: \`intent decide "Title" -d "Why"\`
+- Create stories: \`intent add "title" --activity "Name"\`
+- Refresh context: \`intent sync\`
+
+## The acceptance-criteria loop
+- Each "Done when" criterion carries a priority (\`must\`/\`should\`) and a
+  verification method: \`[executable]\` gives a \`check:\` command to run;
+  \`[self-check]\`/\`[visual]\`/\`[founder]\` give a \`check:\` question to answer.
+- After implementing, evaluate every criterion and report results with the
+  \`report_criteria\` MCP tool: \`{ story_id, results: [{ criterion_id, status: pass|fail|blocked, detail }] }\`
+- For a failing \`must\` criterion: fix and re-check. If the same \`must\`
+  fails 3 times, call \`raise_blocker\` with what you attempted, what's
+  failing, and the single decision needed \u2014 then stop.
+- Never call \`mark_done\`/\`intent done\` while a \`must\` criterion is still
+  failing or unreported \u2014 both warn and require an explicit override.
+
+## Rules
+- Read acceptance criteria before implementing
+- Don't over-engineer \u2014 build what's needed
+- Log decisions and trade-offs back to intentdocs
+- Follow patterns in CONVENTIONS.md
+`;
+  if (existsSync2(cursorRulesPath)) {
+    const existing = readFileSync(cursorRulesPath, "utf-8");
+    if (!existing.includes("intentdocs Integration")) {
+      writeFileSync2(cursorRulesPath, existing + "\n" + cursorBlock);
+      console.log("  \u2713 Updated .cursorrules");
+    }
+  } else {
+    writeFileSync2(cursorRulesPath, cursorBlock.trim() + "\n");
+    console.log("  \u2713 Created .cursorrules");
+  }
+  console.log(`
+  To enable MCP tools in Cursor:
+
+  {
+    "mcpServers": {
+      "intentdocs": {
+        "command": "npx",
+        "args": ["intentdocs", "mcp"],
+        "cwd": "${cwd}"
+      }
+    }
+  }
+`);
+}
+function generateAgentDocs() {
+  const cwd = process.cwd();
+  const archPath = join2(cwd, "ARCHITECTURE.md");
+  if (!existsSync2(archPath)) {
+    writeFileSync2(
+      archPath,
+      `# Architecture
+
+Document technical decisions here. Your AI tool reads this before implementing features.
+
+## Decisions
+
+| Date | Decision | Rationale |
+|------|----------|-----------|
+| ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]} | Project initialised with intentdocs | Story-map-driven development |
+
+## Stack
+
+_Fill in your tech stack here._
+
+## Patterns
+
+_Document recurring patterns._
+
+## Trade-offs
+
+_Record trade-offs and why._
+`
+    );
+    console.log("  \u2713 Created ARCHITECTURE.md scaffold");
+  }
+  const convPath = join2(cwd, "CONVENTIONS.md");
+  if (!existsSync2(convPath)) {
+    writeFileSync2(
+      convPath,
+      `# Conventions
+
+Coding rules for this project. Your AI tool follows these when writing code.
+
+## File structure
+
+_Describe your preferred file/folder structure._
+
+## Naming
+
+_Naming conventions (camelCase, PascalCase, etc.)._
+
+## Testing
+
+_Testing patterns._
+
+## Git
+
+- Branches: \`feat/<description>\`, \`fix/<description>\`
+- Commits: \`feat: description [INTENT-<story-id>]\`
+- Always create PRs \u2014 never commit directly to main
+
+## Code style
+
+_Linting, formatting, style preferences._
+`
+    );
+    console.log("  \u2713 Created CONVENTIONS.md scaffold");
+  }
+}
+
+export {
+  captureCli,
+  shutdownCliAnalytics,
+  sync,
+  setup
+};

package/dist/chunk-ITQUQYWB.js

@@ -0,0 +1,21 @@
+// src/lib/upgrade.ts
+import chalk from "chalk";
+function isPlanGated(status) {
+  return status === 402 || status === 403;
+}
+var UPGRADE_MESSAGE_PLAIN = "This feature requires a Pro plan or your own Anthropic key.\n  Upgrade: https://intentdocs.com/pricing\n  Or add your key: intent keys set";
+function printUpgradeMessage() {
+  console.log();
+  console.log(
+    `  ${chalk.yellow("This feature requires a Pro plan or your own Anthropic key.")}`
+  );
+  console.log(`    Upgrade: ${chalk.cyan.underline("https://intentdocs.com/pricing")}`);
+  console.log(`    Or add your key: ${chalk.cyan("intent keys set")}`);
+  console.log();
+}
+
+export {
+  isPlanGated,
+  UPGRADE_MESSAGE_PLAIN,
+  printUpgradeMessage
+};

package/dist/chunk-PCNDP5SX.js

@@ -0,0 +1,34 @@
+// src/lib/auth.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var AUTH_DIR = join(homedir(), ".intent");
+var AUTH_FILE = join(AUTH_DIR, "auth.json");
+function getAuth() {
+  try {
+    const raw = readFileSync(AUTH_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveAuth(data) {
+  if (!existsSync(AUTH_DIR)) mkdirSync(AUTH_DIR, { recursive: true });
+  writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
+}
+function requireAuth() {
+  const auth = getAuth();
+  if (!auth) {
+    console.error("Not logged in. Run: intent login");
+    process.exit(1);
+  }
+  return auth;
+}
+var API_BASE = "https://intentdocs.com";
+
+export {
+  getAuth,
+  saveAuth,
+  requireAuth,
+  API_BASE
+};