create-me-txt 0.1.0

package/README.md

@@ -0,0 +1,150 @@
+# create-me-txt
+
+CLI tool to generate, validate, and fetch [me.txt](https://metxt.dev) files — the open standard for personal AI-readable identity.
+
+## Quick Start
+
+```bash
+npx create-me-txt
+```
+
+## Installation
+
+```bash
+npm install -g create-me-txt
+# or
+pnpm add -g create-me-txt
+```
+
+This installs two binaries: `create-me-txt` (generator) and `me-txt` (utility commands).
+
+## Usage
+
+### Generate a me.txt
+
+Run the interactive wizard:
+
+```bash
+create-me-txt
+# or
+create-me-txt generate
+```
+
+Pre-fill from your GitHub profile:
+
+```bash
+create-me-txt generate --github yourusername
+```
+
+Include all optional sections (Writing, Talks, Optional):
+
+```bash
+create-me-txt generate --full
+```
+
+Skip prompts and generate from flags only:
+
+```bash
+create-me-txt generate --github yourusername --yes
+```
+
+Output as JSON:
+
+```bash
+create-me-txt generate --github yourusername --yes --json
+```
+
+Specify output path:
+
+```bash
+create-me-txt generate -o public/me.txt
+```
+
+### Validate a me.txt
+
+```bash
+me-txt lint me.txt
+```
+
+Example output:
+
+```
+  ✓ Valid me.txt (spec v0.1)
+  ℹ 6 sections found: Now, Skills, Stack, Links, Preferences
+  ℹ Estimated token count: ~340 tokens
+```
+
+### Fetch someone's me.txt
+
+```bash
+me-txt fetch example.com
+```
+
+The fetch command tries these URLs in order:
+1. `https://example.com/me.txt`
+2. `https://example.com/.well-known/me.txt`
+3. `https://metxt.dev/api/lookup` (directory fallback)
+
+Print full contents:
+
+```bash
+me-txt fetch example.com --print
+```
+
+Save to a file:
+
+```bash
+me-txt fetch example.com --save their-me.txt
+```
+
+## me.txt Format
+
+```markdown
+# Your Name
+
+> One-line summary of who you are and what you do.
+
+## Now
+
+What you're currently working on or focused on.
+
+## Skills
+
+- Skill 1
+- Skill 2
+- Skill 3
+
+## Stack
+
+- Technology 1
+- Technology 2
+
+## Work
+
+- [Project Name](url) - Description
+- Company Name - Role
+
+## Links
+
+- [GitHub](https://github.com/username): Open source projects
+- [Website](https://example.com): Blog and portfolio
+- [Twitter](https://twitter.com/username): Tech thoughts
+
+## Preferences
+
+- Timezone: EST / UTC-5
+- Contact: Email for serious inquiries
+- Response time: 24-48 hours
+```
+
+## Programmatic API
+
+```typescript
+import { parse } from 'create-me-txt'
+```
+
+The package exports the parser, validator, renderer, and token estimator for use in other tools.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/generate.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { writeFileSync } from "fs";
+import { resolve } from "path";
+
+// src/lib/parser.ts
+var LINK_RE = /^-\s+\[([^\]]+)\]\(([^)]+)\)(?:\s*[:\u2014\u2013-]\s*(.+))?$/;
+var AVATAR_RE = /^!\[([^\]]*)\]\(([^)]+)\)$/;
+function parseLink(line) {
+  const match = line.match(LINK_RE);
+  if (!match) return null;
+  return {
+    title: match[1],
+    url: match[2],
+    ...match[3] ? { description: match[3].trim() } : {}
+  };
+}
+function parse(content) {
+  const lines = content.split("\n");
+  let name = "";
+  let summary = "";
+  let avatar;
+  const aboutLines = [];
+  const sections = [];
+  let currentSection = null;
+  let foundFirstH2 = false;
+  let foundName = false;
+  let foundSummary = false;
+  for (const line of lines) {
+    if (line.startsWith("# ") && !foundName) {
+      name = line.slice(2).trim();
+      foundName = true;
+      continue;
+    }
+    if (line.startsWith("> ") && !foundSummary && !foundFirstH2) {
+      summary = line.slice(2).trim();
+      foundSummary = true;
+      continue;
+    }
+    if (line.startsWith("## ")) {
+      foundFirstH2 = true;
+      if (currentSection) {
+        sections.push(currentSection);
+      }
+      const heading = line.slice(3).trim();
+      currentSection = {
+        heading,
+        content: [],
+        links: [],
+        isOptional: heading.toLowerCase() === "optional"
+      };
+      continue;
+    }
+    if (!foundFirstH2 && foundName && line.trim()) {
+      const avatarMatch = line.match(AVATAR_RE);
+      if (avatarMatch && !avatar) {
+        avatar = avatarMatch[2];
+        continue;
+      }
+      aboutLines.push(line);
+      continue;
+    }
+    if (currentSection && line.trim()) {
+      currentSection.content.push(line);
+      const link = parseLink(line);
+      if (link) {
+        currentSection.links.push(link);
+      }
+    }
+  }
+  if (currentSection) {
+    sections.push(currentSection);
+  }
+  return {
+    name,
+    summary,
+    ...avatar ? { avatar } : {},
+    ...aboutLines.length > 0 ? { about: aboutLines.join("\n") } : {},
+    sections,
+    raw: content
+  };
+}
+
+// src/lib/renderer.ts
+function makeSection(heading, content) {
+  return {
+    heading,
+    content,
+    links: content.map((l) => parseLink(l)).filter((l) => l !== null),
+    isOptional: heading.toLowerCase() === "optional"
+  };
+}
+function render(options) {
+  const lines = [];
+  lines.push(`# ${options.name}`);
+  lines.push("");
+  lines.push(`> ${options.summary}`);
+  lines.push("");
+  if (options.avatar) {
+    lines.push(`![${options.name}](${options.avatar})`);
+    lines.push("");
+  }
+  for (const section of options.sections) {
+    lines.push(`## ${section.heading}`);
+    lines.push("");
+    for (const line of section.content) {
+      lines.push(line);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim() + "\n";
+}
+
+// src/lib/github.ts
+async function fetchGitHubProfile(username) {
+  const userResponse = await fetch(`https://api.github.com/users/${username}`, {
+    headers: {
+      "Accept": "application/vnd.github.v3+json",
+      "User-Agent": "create-me-txt"
+    }
+  });
+  if (!userResponse.ok) {
+    if (userResponse.status === 404) {
+      throw new Error(`GitHub user "${username}" not found`);
+    }
+    throw new Error(`GitHub API error: ${userResponse.status}`);
+  }
+  const user = await userResponse.json();
+  const reposResponse = await fetch(
+    `https://api.github.com/users/${username}/repos?sort=stars&per_page=10`,
+    {
+      headers: {
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "create-me-txt"
+      }
+    }
+  );
+  let repos = [];
+  if (reposResponse.ok) {
+    const reposData = await reposResponse.json();
+    repos = reposData.filter((r) => !r.fork).slice(0, 5).map((r) => ({
+      name: r.name,
+      description: r.description,
+      language: r.language,
+      stars: r.stargazers_count,
+      url: r.html_url
+    }));
+  }
+  return {
+    name: user.name || username,
+    bio: user.bio || "",
+    avatar: user.avatar_url,
+    company: user.company,
+    location: user.location,
+    blog: user.blog,
+    twitter: user.twitter_username,
+    repos
+  };
+}
+function extractLanguages(repos) {
+  const languages = /* @__PURE__ */ new Set();
+  for (const repo of repos) {
+    if (repo.language) {
+      languages.add(repo.language);
+    }
+  }
+  return Array.from(languages);
+}
+function formatRepoAsWork(repo) {
+  const desc = repo.description ? ` - ${repo.description}` : "";
+  return `- [${repo.name}](${repo.url})${desc}`;
+}
+
+// src/commands/generate.ts
+async function generate(options) {
+  p.intro(pc.cyan("create-me-txt"));
+  let name = "";
+  let summary = "";
+  let prefillAvatar = "";
+  let prefillSkills = [];
+  let prefillWork = [];
+  let prefillLinks = [];
+  if (options.github) {
+    const spinner2 = p.spinner();
+    spinner2.start(`Fetching GitHub profile for ${options.github}...`);
+    try {
+      const profile = await fetchGitHubProfile(options.github);
+      spinner2.stop("GitHub profile loaded!");
+      name = profile.name;
+      summary = profile.bio;
+      if (profile.avatar) prefillAvatar = profile.avatar;
+      if (profile.repos.length > 0) {
+        prefillSkills = extractLanguages(profile.repos);
+        prefillWork = profile.repos.map(formatRepoAsWork);
+      }
+      if (profile.blog) {
+        prefillLinks.push(`- [Website](${profile.blog})`);
+      }
+      prefillLinks.push(`- [GitHub](https://github.com/${options.github})`);
+      if (profile.twitter) {
+        prefillLinks.push(`- [Twitter](https://twitter.com/${profile.twitter})`);
+      }
+    } catch (error) {
+      spinner2.stop(pc.red(`Failed to fetch GitHub profile: ${error.message}`));
+    }
+  }
+  if (options.yes) {
+    if (!name) name = "Your Name";
+    if (!summary) summary = "A short summary about yourself";
+    const sections2 = [];
+    if (prefillSkills.length > 0) {
+      sections2.push(makeSection("Skills", prefillSkills.map((s) => `- ${s}`)));
+    }
+    if (prefillWork.length > 0) {
+      sections2.push(makeSection("Work", prefillWork));
+    }
+    if (prefillLinks.length > 0) {
+      sections2.push(makeSection("Links", prefillLinks));
+    }
+    const avatar = prefillAvatar || void 0;
+    const content2 = render({ name, summary, avatar, sections: sections2 });
+    if (options.json) {
+      const parsed = parse(content2);
+      console.log(JSON.stringify(parsed, null, 2));
+      return;
+    }
+    const outputPath2 = options.output || "me.txt";
+    const fullPath2 = resolve(process.cwd(), outputPath2);
+    writeFileSync(fullPath2, content2);
+    p.outro(pc.green(`\u2713 Saved to ${fullPath2}`));
+    return;
+  }
+  const corePrompts = {
+    name: () => p.text({
+      message: "What is your name?",
+      placeholder: "Jane Doe",
+      initialValue: name,
+      validate: (value) => {
+        if (!value.trim()) return "Name is required";
+      }
+    }),
+    summary: () => p.text({
+      message: "Write a one-line summary about yourself.",
+      placeholder: "Full-stack developer building tools for developers.",
+      initialValue: summary,
+      validate: (value) => {
+        if (!value.trim()) return "Summary is required";
+      }
+    }),
+    avatar: () => p.text({
+      message: "Profile picture URL (optional, press enter to skip)",
+      placeholder: "https://example.com/avatar.jpg",
+      initialValue: prefillAvatar
+    }),
+    now: () => p.text({
+      message: "What are you currently working on? (Now section)",
+      placeholder: "Building a new project, learning Rust, etc."
+    }),
+    skills: () => p.text({
+      message: "List your skills (comma-separated)",
+      placeholder: "TypeScript, React, Node.js, PostgreSQL",
+      initialValue: prefillSkills.join(", ")
+    }),
+    stack: () => p.text({
+      message: "What is your preferred tech stack? (comma-separated)",
+      placeholder: "TypeScript, Next.js, Tailwind, Prisma"
+    }),
+    work: () => p.text({
+      message: "List notable work/projects (one per line, use - prefix)",
+      placeholder: "- Project Name - Description",
+      initialValue: prefillWork.join("\n")
+    }),
+    links: () => p.text({
+      message: "Add your links (one per line, use markdown format)",
+      placeholder: "- [GitHub](https://github.com/username)",
+      initialValue: prefillLinks.join("\n")
+    }),
+    timezone: () => p.text({
+      message: "What is your timezone?",
+      placeholder: "EST / UTC-5"
+    }),
+    contactPref: () => p.text({
+      message: "How do you prefer to be contacted?",
+      placeholder: "Email for serious inquiries, DM for quick questions"
+    }),
+    responseTime: () => p.text({
+      message: "What is your typical response time?",
+      placeholder: "24-48 hours"
+    })
+  };
+  const fullPrompts = options.full ? {
+    ...corePrompts,
+    writing: () => p.text({
+      message: "List your writing/publications (one per line, use markdown format)",
+      placeholder: "- [Blog Post Title](https://example.com/post)"
+    }),
+    talks: () => p.text({
+      message: "List your talks/presentations (one per line, use markdown format)",
+      placeholder: "- [Talk Title](https://youtube.com/...)"
+    }),
+    optional: () => p.text({
+      message: "Anything else? Hobbies, personal details, etc.",
+      placeholder: "Coffee enthusiast, dog person, amateur photographer"
+    })
+  } : corePrompts;
+  const answers = await p.group(fullPrompts, {
+    onCancel: () => {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+  });
+  const sections = [];
+  if (answers.now) {
+    sections.push(makeSection("Now", [answers.now]));
+  }
+  if (answers.skills) {
+    sections.push(makeSection("Skills", answers.skills.split(",").map((s) => `- ${s.trim()}`)));
+  }
+  if (answers.stack) {
+    sections.push(makeSection("Stack", answers.stack.split(",").map((s) => `- ${s.trim()}`)));
+  }
+  if (answers.work) {
+    sections.push(makeSection("Work", answers.work.split("\n").filter((l) => l.trim())));
+  }
+  if ("writing" in answers && answers.writing) {
+    sections.push(makeSection("Writing", answers.writing.split("\n").filter((l) => l.trim())));
+  }
+  if ("talks" in answers && answers.talks) {
+    sections.push(makeSection("Talks", answers.talks.split("\n").filter((l) => l.trim())));
+  }
+  if (answers.links) {
+    sections.push(makeSection("Links", answers.links.split("\n").filter((l) => l.trim())));
+  }
+  const preferences = [];
+  if (answers.timezone) preferences.push(`- Timezone: ${answers.timezone}`);
+  if (answers.contactPref) preferences.push(`- Contact: ${answers.contactPref}`);
+  if (answers.responseTime) preferences.push(`- Response time: ${answers.responseTime}`);
+  if (preferences.length > 0) {
+    sections.push(makeSection("Preferences", preferences));
+  }
+  if ("optional" in answers && answers.optional) {
+    sections.push(makeSection("Optional", [answers.optional]));
+  }
+  const content = render({
+    name: answers.name,
+    summary: answers.summary,
+    avatar: answers.avatar || void 0,
+    sections
+  });
+  if (options.json) {
+    const parsed = parse(content);
+    console.log(JSON.stringify(parsed, null, 2));
+    return;
+  }
+  p.note(content, "Preview");
+  const outputPath = options.output || "me.txt";
+  const shouldSave = await p.confirm({
+    message: `Save to ${outputPath}?`,
+    initialValue: true
+  });
+  if (p.isCancel(shouldSave) || !shouldSave) {
+    p.cancel("File not saved.");
+    return;
+  }
+  const fullPath = resolve(process.cwd(), outputPath);
+  writeFileSync(fullPath, content);
+  p.outro(pc.green(`\u2713 Saved to ${fullPath}`));
+}
+
+// src/commands/lint.ts
+import { readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+import pc2 from "picocolors";
+
+// src/types.ts
+var STANDARD_SECTIONS = [
+  "Now",
+  "Skills",
+  "Stack",
+  "Work",
+  "Writing",
+  "Talks",
+  "Links",
+  "Preferences",
+  "Optional"
+];
+var SPEC_VERSION = "0.1";
+
+// src/lib/tokens.ts
+function estimateTokens(content) {
+  if (!content.trim()) return 0;
+  const stripped = content.replace(/^#{1,6}\s/gm, "").replace(/^>\s/gm, "").replace(/^-\s/gm, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\n{2,}/g, "\n");
+  const words = stripped.split(/\s+/).filter(Boolean);
+  const charCount = stripped.replace(/\s+/g, "").length;
+  const wordEstimate = Math.ceil(words.length * 1.3);
+  const charEstimate = Math.ceil(charCount / 4);
+  return Math.round((wordEstimate + charEstimate) / 2);
+}
+
+// src/lib/validator.ts
+function validate(content) {
+  const parsed = parse(content);
+  const errors = [];
+  const warnings = [];
+  const lines = content.split("\n");
+  if (!parsed.name) {
+    errors.push({ message: "Missing name (H1 heading)", rule: "MISSING_NAME" });
+  }
+  if (!parsed.summary) {
+    errors.push({ message: "Missing summary (blockquote after H1)", rule: "MISSING_SUMMARY" });
+  }
+  if (parsed.sections.length === 0) {
+    errors.push({ message: "No sections found (H2 headings)", rule: "MISSING_SECTION" });
+  }
+  if (parsed.summary && parsed.summary.length > 200) {
+    warnings.push({ message: "Summary exceeds 200 characters", rule: "LONG_SUMMARY" });
+  }
+  if (lines.length > 500) {
+    warnings.push({
+      message: `File is ${lines.length} lines (recommended: under 500)`,
+      rule: "FILE_TOO_LONG"
+    });
+  }
+  for (const section of parsed.sections) {
+    if (section.content.length === 0) {
+      warnings.push({
+        message: `Section "${section.heading}" is empty`,
+        rule: "EMPTY_SECTION"
+      });
+    }
+    if (!STANDARD_SECTIONS.includes(section.heading)) {
+      warnings.push({
+        message: `Non-standard section "${section.heading}"`,
+        rule: "UNKNOWN_SECTION"
+      });
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("- [")) {
+      const linkMatch = line.match(/^-\s+\[([^\]]*)\]\(([^)]*)\)/);
+      if (linkMatch && !linkMatch[2]) {
+        errors.push({
+          line: i + 1,
+          message: `Empty URL in link "${linkMatch[1]}"`,
+          rule: "EMPTY_LINK_URL"
+        });
+      }
+    }
+  }
+  const tokens = estimateTokens(content);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    info: {
+      sectionCount: parsed.sections.length,
+      sections: parsed.sections.map((s) => s.heading),
+      estimatedTokens: tokens,
+      lineCount: lines.length
+    }
+  };
+}
+
+// src/commands/lint.ts
+async function lint(filePath) {
+  const fullPath = resolve2(process.cwd(), filePath);
+  let content;
+  try {
+    content = readFileSync(fullPath, "utf-8");
+  } catch {
+    console.error(pc2.red(`Error: Could not read file "${filePath}"`));
+    process.exit(1);
+  }
+  const result = validate(content);
+  console.log();
+  if (result.valid) {
+    console.log(pc2.green(`  \u2713 Valid me.txt (spec v${SPEC_VERSION})`));
+  } else {
+    console.log(pc2.red(`  \u2717 Invalid me.txt (spec v${SPEC_VERSION})`));
+  }
+  if (result.info.sectionCount > 0) {
+    console.log(pc2.cyan(`  \u2139 ${result.info.sectionCount} sections found: ${result.info.sections.join(", ")}`));
+  }
+  console.log(pc2.cyan(`  \u2139 Estimated token count: ~${result.info.estimatedTokens} tokens`));
+  if (result.errors.length > 0) {
+    console.log();
+    for (const error of result.errors) {
+      const loc = error.line ? ` (line ${error.line})` : "";
+      console.log(pc2.red(`  \u2717 ${error.message}${loc}`));
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.log();
+    for (const warning of result.warnings) {
+      const loc = warning.line ? ` (line ${warning.line})` : "";
+      console.log(pc2.yellow(`  \u26A0 ${warning.message}${loc}`));
+    }
+  }
+  console.log();
+  if (!result.valid) {
+    process.exit(1);
+  }
+}
+
+// src/commands/fetch.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+import pc3 from "picocolors";
+function buildUrls(urlOrDomain) {
+  let base = urlOrDomain;
+  if (!base.startsWith("http://") && !base.startsWith("https://")) {
+    base = `https://${base}`;
+  }
+  if (base.endsWith("/me.txt") || base.endsWith("/.well-known/me.txt")) {
+    return [base];
+  }
+  base = base.replace(/\/$/, "");
+  return [
+    `${base}/me.txt`,
+    `${base}/.well-known/me.txt`
+  ];
+}
+async function tryFetch(url) {
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "create-me-txt",
+        "Accept": "text/plain, text/markdown"
+      }
+    });
+    if (response.ok) {
+      return { content: await response.text(), resolvedUrl: url };
+    }
+  } catch {
+  }
+  return null;
+}
+async function fetchMeTxt(urlOrDomain, options) {
+  const urls = buildUrls(urlOrDomain);
+  let result = null;
+  for (const url of urls) {
+    console.log(pc3.dim(`  Fetching ${url}...`));
+    result = await tryFetch(url);
+    if (result) break;
+  }
+  if (!result) {
+    let domain = urlOrDomain.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+    console.log(pc3.dim(`  Trying metxt.dev directory for ${domain}...`));
+    try {
+      const apiResp = await fetch(`https://metxt.dev/api/lookup?domain=${encodeURIComponent(domain)}`, {
+        headers: { "User-Agent": "create-me-txt", "Accept": "application/json" }
+      });
+      if (apiResp.ok) {
+        const data = await apiResp.json();
+        if (data.raw_markdown) {
+          result = { content: data.raw_markdown, resolvedUrl: data.url || `https://${domain}/me.txt` };
+        }
+      }
+    } catch {
+    }
+  }
+  if (!result) {
+    console.error(pc3.red(`
+  No me.txt found for "${urlOrDomain}"`));
+    console.error(pc3.dim("  Tried:"));
+    for (const url of urls) {
+      console.error(pc3.dim(`    - ${url}`));
+    }
+    console.error(pc3.dim("    - metxt.dev directory"));
+    process.exit(1);
+  }
+  const { content, resolvedUrl } = result;
+  const parsed = parse(content);
+  const validation = validate(content);
+  console.log();
+  console.log(`  ${pc3.green("\u2713")} Found valid me.txt for ${pc3.bold(parsed.name)}`);
+  if (parsed.summary) {
+    console.log(`  ${pc3.dim("\u2192")} ${parsed.summary}`);
+  }
+  console.log();
+  console.log(pc3.dim(`  Sections: ${validation.info.sections.join(", ")}`));
+  console.log(pc3.dim(`  Tokens: ~${validation.info.estimatedTokens}`));
+  if (!validation.valid) {
+    console.log();
+    console.log(pc3.yellow("  Warning: This me.txt has validation issues"));
+    for (const err of validation.errors) {
+      console.log(pc3.yellow(`    \u2717 ${err.message}`));
+    }
+  }
+  const savePath = options.output || options.save;
+  if (savePath) {
+    const outputPath = resolve3(process.cwd(), savePath);
+    writeFileSync2(outputPath, content);
+    console.log();
+    console.log(pc3.green(`  \u2713 Saved to ${outputPath}`));
+  } else if (options.print) {
+    console.log();
+    console.log(pc3.dim("  ---"));
+    console.log(content);
+  } else {
+    console.log();
+    console.log(pc3.dim(`  Use --print to display full contents`));
+    console.log(pc3.dim(`  Use --save <path> to save locally`));
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("create-me-txt").description("CLI tool to generate, validate, and fetch me.txt files").version("0.1.0");
+program.command("generate", { isDefault: true }).description("Generate a new me.txt file interactively").option("-g, --github <username>", "Pre-fill from GitHub profile").option("-o, --output <path>", "Output file path", "me.txt").option("--json", "Output as JSON instead of markdown").option("-y, --yes", "Skip prompts, use defaults and flags").option("--full", "Include all optional sections in wizard").action(async (options) => {
+  await generate(options);
+});
+program.command("lint <file>").description("Validate a me.txt file").action(async (file) => {
+  await lint(file);
+});
+program.command("fetch <url>").description("Fetch and display a me.txt from a URL or domain").option("-o, --output <path>", "Save to file").option("-s, --save <path>", "Save to file (alias for --output)").option("-p, --print", "Print full contents to stdout").action(async (url, options) => {
+  await fetchMeTxt(url, options);
+});
+program.parse();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "create-me-txt",
+  "version": "0.1.0",
+  "description": "CLI tool to generate, validate, and fetch me.txt files",
+  "type": "module",
+  "bin": {
+    "create-me-txt": "./dist/index.js",
+    "me-txt": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "me.txt",
+    "identity",
+    "llm",
+    "ai",
+    "personal",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "commander": "^12.0.0",
+    "picocolors": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}