@jairodri/huckleberry-cli 1.0.2 → 1.1.0

package/skills/auto-indexing/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: auto-indexing
+description: Automatically submit published articles to participating search engines (Bing, Yandex, Seznam via IndexNow) for faster indexing. Google is NOT an IndexNow participant — Google indexing requires sitemap submission in Search Console + manual URL inspection there.
+---
+
+# Auto-Indexing Skill
+
+Automatically submit published articles to search engines for faster indexing.
+
+## Purpose
+
+After validating your site with Bing Webmaster Tools, this skill automates the indexing-ping process for every new article you publish. No manual submission required for IndexNow-participant engines.
+
+**CRITICAL — Google coverage gap:** Google never joined IndexNow and deprecated its sitemap ping endpoint (2023). IndexNow submissions do NOT reach Google in any way. For Google you must: (1) submit your sitemap in Google Search Console, and (2) optionally request indexing per-URL via Search Console URL Inspection ("Request indexing").
+
+## When to Use
+
+**Invoke this skill**:
+- After publishing a new blog article
+- After updating an existing article significantly
+- When you want to force re-indexing of a page
+
+**Trigger phrases**:
+- "submit the article for indexing"
+- "index this article"
+- "notify search engines about the new article"
+- "auto-index the published article"
+
+## What It Does
+
+1. **IndexNow Protocol** (Priority Method)
+   - Instantly notifies participating engines: Bing, Yandex, Seznam, Naver (+ all IndexNow participants) — **NOT Google**
+   - No API limits, completely free
+   - Typically crawled within 24-48 hours by participants
+
+2. **Sitemap Submission** (Google path)
+   - Google ignores IndexNow and killed its ping endpoint (`google.com/ping?sitemap=` → 404, deprecated 2023; Bing's → 410)
+   - Submit the sitemap once in Google Search Console → Sitemaps; Google then discovers new URLs from it
+   - Per-URL acceleration: Search Console → URL Inspection → "Request indexing" (UI only — no API)
+
+3. **Key Management**
+   - Auto-generates IndexNow key on first use
+   - Saves key to `.indexnow-key.txt`
+   - Provides instructions for uploading key file to site
+
+## Prerequisites
+
+**One-time setup** (after validating your site):
+
+1. **Verify ownership** in Google Search Console and Bing Webmaster Tools
+2. **Upload IndexNow key** to your site root (skill will generate and guide you)
+
+That's it! After initial setup, indexing is fully automated.
+
+## How to Use
+
+### Basic Usage
+
+```
+Skill: auto-indexing
+
+User provides:
+- Article URL: https://www.thegptshop.online/blog/monetize-custom-gpts-2025
+```
+
+### Advanced Usage
+
+```
+Skill: auto-indexing
+
+With options:
+- Article URL: https://example.com/blog/article
+- Sitemap URL: https://example.com/sitemap.xml (optional, auto-detected)
+- Force re-index: true (for updated articles)
+```
+
+## Integration with Publishing Workflow
+
+**Recommended workflow**:
+1. Publish article with `github-blog-publisher` skill
+2. Verify article is live
+3. Invoke `auto-indexing` skill
+4. Skill notifies all search engines automatically
+
+**Optional automation**: Add to github-blog-publisher post-publish hook
+
+## Technical Details
+
+**Methods Used**:
+- **IndexNow**: HTTP POST to api.indexnow.org (Bing, Yandex, Seznam + participants — NOT Google)
+- **Sitemap Ping**: DEPRECATED — Google endpoint 404, Bing endpoint 410 (live-verified 2026-09). Do not rely on it.
+- **Google Indexing API**: Limited to JobPosting/BroadcastEvent types only; not applicable to blog content
+
+**Timeline**:
+- Submission: Instant (< 5 seconds)
+- Crawling by IndexNow participants: 24-48 hours
+- Google: no fixed timeline — depends on sitemap submission in GSC, crawl budget, and internal links
+
+**Cost**: Free (no API limits, no rate limits)
+
+## Outputs
+
+**Success**:
+```
+✅ IndexNow submission successful
+   Notified: Bing, Yandex, Seznam (+ all IndexNow participants)
+✨ Article submitted for crawling!
+   Expected: Crawled by participants within 24-48 hours
+ℹ️  Google NOT notified — submit sitemap in Search Console and/or use URL Inspection → Request indexing
+```
+
+**First-time setup**:
+```
+🔑 Generated new IndexNow key: abc123...
+📝 Key saved to: .indexnow-key.txt
+
+⚠️  IMPORTANT: Upload this key file to your site root:
+   https://thegptshop.online/abc123....txt
+   Content: abc123...
+```
+
+## Troubleshooting
+
+**Key file not uploaded**:
+- Skill generates key and provides upload instructions
+- Upload to `public/[key].txt` in your Next.js site
+- Redeploy site after uploading key
+
+**Submission failed**:
+- Check network connectivity
+- Verify site URL is correct
+- Check Search Console for manual submission as fallback
+
+**Article not indexed after 72 hours**:
+- Verify robots.txt allows crawling
+- Check Google Search Console > Coverage report
+- Add internal links to the article
+- Request manual indexing in Search Console
+
+## Examples
+
+### Example 1: Index New Article
+```
+User: "I just published the Custom GPTs article, can you submit it for indexing?"
+Assistant: "I'll submit your article to search engines for automatic indexing."
+*Invokes auto-indexing skill*
+Result: Article submitted to Bing, Yandex, Seznam via IndexNow (Google requires GSC sitemap submission / URL Inspection)
+```
+
+### Example 2: After Publishing Workflow
+```
+User: "Publish this article about AI automation"
+Assistant: *Uses github-blog-publisher skill*
+Assistant: "Article published successfully! Would you like me to submit it for search engine indexing?"
+User: "Yes"
+Assistant: *Invokes auto-indexing skill*
+Result: Crawled by IndexNow participants within 24-48 hours (Google indexing depends on GSC sitemap + crawl)
+```
+
+### Example 3: Re-index Updated Article
+```
+User: "I updated the monetization guide, can you re-submit it for indexing?"
+Assistant: *Invokes auto-indexing skill with force flag*
+Result: Search engines notified of updated content
+```
+
+## Notes
+
+- **No rate limits**: Unlike Google Indexing API, IndexNow has no submission limits
+- **Multiple search engines**: One submission notifies all participating search engines
+- **Instant notification**: Submission completes in seconds
+- **Free forever**: No API costs or subscription fees
+- **Works globally, EXCEPT Google**: IndexNow participants cover Bing/Yandex/Seznam/Naver traffic — Google (~90% of global search) is NOT covered and needs Search Console workflows
+
+## Files
+
+- `/scripts/auto-indexing.js` - Core indexing logic
+- `.indexnow-key.txt` - Generated IndexNow key (gitignored)
+- Integration with github-blog-publisher skill

package/skills/auto-indexing/scripts/auto-indexing.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+/**
+ * Automated Search Engine Indexing
+ *
+ * Automatically submits URLs to search engines after publishing
+ *
+ * Methods:
+ * 1. IndexNow Protocol - Instant notification (Google, Bing, Yandex, Seznam)
+ * 2. Google Indexing API - Priority indexing for critical pages
+ * 3. Sitemap ping - Standard notification method
+ *
+ * Usage:
+ *   node auto-indexing.js --url "https://example.com/blog/article" --sitemap "https://example.com/sitemap.xml"
+ */
+
+const https = require('https');
+const http = require('http');
+const crypto = require('crypto');
+const fs = require('fs').promises;
+const path = require('path');
+
+class AutoIndexing {
+  constructor(siteUrl) {
+    this.siteUrl = siteUrl;
+    this.indexNowKey = null;
+  }
+
+  /**
+   * Generate or load IndexNow key
+   */
+  async getIndexNowKey() {
+    if (this.indexNowKey) return this.indexNowKey;
+
+    const keyPath = path.join(process.cwd(), '.indexnow-key.txt');
+
+    try {
+      // Try to load existing key
+      this.indexNowKey = await fs.readFile(keyPath, 'utf-8');
+      console.log('✅ Loaded existing IndexNow key');
+    } catch (error) {
+      // Generate new key
+      this.indexNowKey = crypto.randomBytes(32).toString('hex');
+      await fs.writeFile(keyPath, this.indexNowKey);
+      console.log('🔑 Generated new IndexNow key:', this.indexNowKey);
+      console.log(`📝 Key saved to: ${keyPath}`);
+      console.log(`\n⚠️  IMPORTANT: Upload this key file to your site root:`);
+      console.log(`   https://${new URL(this.siteUrl).hostname}/${this.indexNowKey}.txt`);
+      console.log(`   Content: ${this.indexNowKey}\n`);
+    }
+
+    return this.indexNowKey;
+  }
+
+  /**
+   * Submit URL via IndexNow protocol
+   * @param {string[]} urls - URLs to submit
+   * @returns {Promise<boolean>}
+   */
+  async submitIndexNow(urls) {
+    const key = await this.getIndexNowKey();
+    const hostname = new URL(this.siteUrl).hostname;
+
+    const payload = {
+      host: hostname,
+      key: key,
+      keyLocation: `https://${hostname}/${key}.txt`,
+      urlList: urls
+    };
+
+    return new Promise((resolve, reject) => {
+      const data = JSON.stringify(payload);
+      const options = {
+        hostname: 'api.indexnow.org',
+        path: '/indexnow',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': data.length
+        }
+      };
+
+      console.log('\n📡 Submitting to IndexNow...');
+      console.log(`URLs: ${urls.join(', ')}`);
+
+      const req = https.request(options, (res) => {
+        if (res.statusCode === 200 || res.statusCode === 202) {
+          console.log('✅ IndexNow submission successful');
+          console.log('   Status:', res.statusCode);
+          console.log('   Notified: Google, Bing, Yandex, Seznam');
+          resolve(true);
+        } else {
+          console.error('❌ IndexNow submission failed');
+          console.error('   Status:', res.statusCode);
+          resolve(false);
+        }
+      });
+
+      req.on('error', (error) => {
+        console.error('❌ IndexNow request error:', error.message);
+        resolve(false);
+      });
+
+      req.write(data);
+      req.end();
+    });
+  }
+
+  /**
+   * Ping sitemap to search engines
+   * @param {string} sitemapUrl - Full URL to sitemap
+   */
+  async pingSitemap(sitemapUrl) {
+    console.log('\n📍 Pinging sitemap to search engines...');
+
+    const engines = [
+      {
+        name: 'Google',
+        url: `https://www.google.com/ping?sitemap=${encodeURIComponent(sitemapUrl)}`
+      },
+      {
+        name: 'Bing',
+        url: `https://www.bing.com/ping?sitemap=${encodeURIComponent(sitemapUrl)}`
+      }
+    ];
+
+    const results = await Promise.allSettled(
+      engines.map(engine => this.pingUrl(engine.url, engine.name))
+    );
+
+    const successful = results.filter(r => r.status === 'fulfilled' && r.value).length;
+    console.log(`✅ Sitemap pinged successfully to ${successful}/${engines.length} search engines`);
+  }
+
+  /**
+   * Ping a URL
+   */
+  async pingUrl(url, name) {
+    return new Promise((resolve) => {
+      const client = url.startsWith('https') ? https : http;
+
+      client.get(url, (res) => {
+        if (res.statusCode === 200) {
+          console.log(`   ✓ ${name}`);
+          resolve(true);
+        } else {
+          console.log(`   ✗ ${name} (${res.statusCode})`);
+          resolve(false);
+        }
+      }).on('error', (error) => {
+        console.log(`   ✗ ${name} (${error.message})`);
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Submit URL to Google Indexing API
+   * Requires service account credentials
+   * @param {string} url - URL to index
+   */
+  async submitGoogleIndexingAPI(url) {
+    // This requires Google Cloud service account setup
+    // For now, we'll use IndexNow which is simpler and free
+    console.log('\n💡 Google Indexing API requires service account setup');
+    console.log('   Using IndexNow instead (instant, free, no limits)');
+    return false;
+  }
+
+  /**
+   * Complete indexing workflow
+   * @param {string} articleUrl - URL of published article
+   * @param {string} sitemapUrl - URL of sitemap
+   */
+  async indexArticle(articleUrl, sitemapUrl) {
+    console.log('\n🚀 Starting automated indexing workflow...');
+    console.log(`Article: ${articleUrl}`);
+    console.log(`Sitemap: ${sitemapUrl}`);
+
+    const results = {
+      indexNow: false,
+      sitemapPing: false,
+      timestamp: new Date().toISOString()
+    };
+
+    // 1. IndexNow (priority method)
+    try {
+      results.indexNow = await this.submitIndexNow([articleUrl]);
+    } catch (error) {
+      console.error('IndexNow error:', error.message);
+    }
+
+    // 2. Sitemap ping (fallback)
+    try {
+      await this.pingSitemap(sitemapUrl);
+      results.sitemapPing = true;
+    } catch (error) {
+      console.error('Sitemap ping error:', error.message);
+    }
+
+    // Summary
+    console.log('\n📊 Indexing Summary:');
+    console.log(`   IndexNow: ${results.indexNow ? '✅ Success' : '❌ Failed'}`);
+    console.log(`   Sitemap Ping: ${results.sitemapPing ? '✅ Success' : '❌ Failed'}`);
+
+    if (results.indexNow || results.sitemapPing) {
+      console.log('\n✨ Article submitted for indexing!');
+      console.log('   Expected: Indexed within 24-48 hours');
+    } else {
+      console.log('\n⚠️  All methods failed - manual submission required');
+    }
+
+    return results;
+  }
+}
+
+// CLI usage
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Parse arguments
+  let articleUrl = null;
+  let sitemapUrl = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--url' && args[i + 1]) {
+      articleUrl = args[i + 1];
+    }
+    if (args[i] === '--sitemap' && args[i + 1]) {
+      sitemapUrl = args[i + 1];
+    }
+  }
+
+  if (!articleUrl) {
+    console.error('❌ Missing --url parameter');
+    console.log('\nUsage:');
+    console.log('  node auto-indexing.js --url "https://example.com/article" --sitemap "https://example.com/sitemap.xml"');
+    process.exit(1);
+  }
+
+  // Extract site URL from article URL
+  const siteUrl = new URL(articleUrl).origin;
+
+  // Default sitemap if not provided
+  if (!sitemapUrl) {
+    sitemapUrl = `${siteUrl}/sitemap.xml`;
+  }
+
+  const indexer = new AutoIndexing(siteUrl);
+  await indexer.indexArticle(articleUrl, sitemapUrl);
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+module.exports = { AutoIndexing };

package/skills/auto-skill/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: auto-skill
+description: "Automatic skill development pipeline. Detects repetitive tasks and user corrections, then creates or improves skills accordingly."
+allowed-tools: []
+---
+
+# /auto-skill — Automatic Skill Development
+
+Detects corrections and repetitive patterns, then creates or improves skills with dedup protection and git versioning.
+
+## How It Works
+
+Three detection mechanisms feed a queue, and this skill processes it:
+
+1. **Correction detection** — User frustration/correction patterns auto-queue skill improvements
+2. **Repetition detection** — Same task pattern 2+ times suggests skill extraction
+3. **Excellence detection** — Exceptional output flagged by user ("this is fucking good," "save this pattern") triggers skill extraction to make it repeatable
+4. **Skill routing** — High-confidence skill matches auto-load (0.8+), medium confidence suggests (0.6+)
+
+## On Activation
+
+1. Read `memory/skill-queue.md` for pending items
+2. If queue is empty, report: "No pending skill improvements."
+3. If queue has items, process each one
+
+## Phase 1: Process Corrections
+
+For each correction in the queue:
+
+1. **Dedup check** — Run `findDuplicateSkill()` against all existing skills
+2. **If match > 0.7** — IMPROVE existing skill:
+   - Read the matching SKILL.md
+   - Add the correction to Anti-Patterns table
+   - Git commit: `skill(<name>): add correction — <summary>`
+3. **If no match** — Draft new skill:
+   - Create entry in queue with `status: pending-approval`
+   - Present to user for approval before creating
+   - NEVER auto-create without human approval
+
+## Phase 2: Process Repetitions
+
+For each repetition (2+ occurrences of same pattern):
+
+1. **Check if existing skill covers it** — Fuzzy match against skill index
+2. **If covered** — Add to that skill's Anti-Patterns: "Agent improvised instead of using this skill"
+3. **If not covered** — Draft new skill with:
+   - Name derived from the repeated pattern
+   - Description capturing what was repeated
+   - Status: `pending-approval`
+   - Present to user for approval
+
+## Phase 3: Process Excellence (Capture Repeatable Greatness)
+
+For each excellence flag (user says "this is great," "save this," "make it repeatable"):
+
+1. **Extract the pattern** — What made it work? (structure, voice, specific techniques, prompt chains)
+2. **Check existing skill coverage** — Does a skill already produce this quality?
+3. **If skill exists** — Add the winning pattern as "Golden Path" example in that skill
+4. **If no skill covers it** — Draft new skill with:
+   - Name from the pattern (e.g., "landing-page-architect" from a great landing page session)
+   - Description capturing the repeatable method
+   - Include the actual working output as reference example
+   - Status: `pending-approval`
+   - Present to user: "You said [X] was excellent. Here's a skill draft to make it repeatable. Approve?"
+
+## Phase 4: Git Versioning
+
+Every skill mutation:
+
+1. Backup current SKILL.md to `skill-history/<name>-<timestamp>.md`
+2. Apply the improvement
+3. Git commit with semantic message: `skill(<name>): <verb> — <reason>`
+4. Append to CHANGELOG.md in skill directory
+
+Verbs: `improve`, `fix-trigger`, `add-anti-pattern`, `merge-from(<source>)`, `create`, `add-golden-path`
+
+## Phase 5: Update Skill Index
+
+After processing, rebuild `memory/skill-index.json`:
+
+```javascript
+// Regenerate the cached index with updated skills
+node -e "const { buildSkillIndex } = require('./.agents/skills/auto-skill/skill-router.js'); ..."
+```
+
+## Anti-Patterns
+
+| Mistake | Why Wrong | Fix |
+|---------|-----------|-----|
+| Creating duplicate skill | 5 blog skills instead of 1 improved one | Always dedup check first |
+| Auto-creating without approval | User loses trust, low quality | New skills need human approval |
+| Skipping git commit | Can't revert bad improvements | Every mutation gets committed |
+| Ignoring skill-router matches | Agent improvises instead of using skill | Auto-load at 0.8+ confidence |
+| **Improvising instead of using skill** | "I can do this better manually" | **ALWAYS check skills first (1b Skill-First Protocol)** |
+
+## Key Rules
+
+- **Auto-USE at 0.8+ confidence** — Don't suggest, just load and execute the skill
+- **Suggest at 0.6-0.8** — Present as option
+- **2 repetitions** = suggest skill creation
+- **Every correction = its own git commit**
+- **New skills require human approval**
+- **Always improve existing before creating new**
+- **Excellence flag = extract pattern within same session** — don't let great work evaporate
+
+## Integration Points
+
+- **memory-system plugin** — Correction detection + skill routing hooks
+- **correction-queue.js** — Queue management module
+- **dedup.js** — Dedup + git versioning module
+- **skill-router.js** — Fuzzy matching + auto-load module
+
+## File Structure
+
+```
+.agents/skills/auto-skill/
+├── SKILL.md              ← this file
+├── skill-router.js       ← fuzzy matching + auto-load
+├── correction-queue.js   ← queue management
+└── dedup.js              ← dedup + git versioning
+```
+
+## Queue File Format
+
+`memory/skill-queue.md` entries:
+
+```markdown
+## Correction — 2026-05-09T18:00:00Z
+- **status:** pending
+- **type:** correction
+- **text:** Why aren't you using the hook generation skill for article titles?
+- **context:** Blog publishing pipeline, Step 1
+- **queued:** 2026-05-09T18:00:00Z
+
+## Repetition — 2026-05-09T18:30:00Z
+- **status:** pending-approval
+- **type:** repetition
+- **pattern:** Generating LinkedIn posts from blog content
+- **count:** 2
+- **context:** content-atomizer runs
+- **queued:** 2026-05-09T18:30:00Z
+
+## Excellence — 2026-06-15T14:00:00Z
+- **status:** pending-approval
+- **type:** excellence
+- **text:** "This landing page is fucking good — make it repeatable"
+- **pattern:** Landing page built section-by-section with 8-section architecture, psychology-aligned CTAs, verification gates
+- **reference_output:** /tmp/landing-page-output.md
+- **context:** landing-page-architect run
+- **queued:** 2026-06-15T14:00:00Z
+```

package/skills/auto-skill/correction-queue.js

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const QUEUE_FILE = 'memory/skill-queue.md';
+const INDEX_FILE = 'memory/skill-index.json';
+
+function ensureQueueFile(projectDir) {
+  const queuePath = path.join(projectDir, QUEUE_FILE);
+  if (!fs.existsSync(queuePath)) {
+    const header = `# Skill Queue
+# Auto-managed by auto-skill system. Do not edit manually.
+# Status values: pending, pending-approval, processing, done, rejected
+
+`;
+    fs.mkdirSync(path.dirname(queuePath), { recursive: true });
+    fs.writeFileSync(queuePath, header, 'utf-8');
+  }
+  return queuePath;
+}
+
+export function queueCorrection(projectDir, correctionText, context = '') {
+  const queuePath = ensureQueueFile(projectDir);
+  const now = new Date().toISOString();
+  const entry = `
+## Correction — ${now}
+- **status:** pending
+- **type:** correction
+- **text:** ${correctionText.replace(/\n/g, ' ').slice(0, 500)}
+- **context:** ${context.replace(/\n/g, ' ').slice(0, 300) || 'none'}
+- **queued:** ${now}
+
+`;
+  fs.appendFileSync(queuePath, entry, 'utf-8');
+  return true;
+}
+
+export function queueRepetition(projectDir, pattern, count, context = '') {
+  const queuePath = ensureQueueFile(projectDir);
+  const now = new Date().toISOString();
+  const entry = `
+## Repetition — ${now}
+- **status:** pending-approval
+- **type:** repetition
+- **pattern:** ${pattern.replace(/\n/g, ' ').slice(0, 500)}
+- **count:** ${count}
+- **context:** ${context.replace(/\n/g, ' ').slice(0, 300) || 'none'}
+- **queued:** ${now}
+
+`;
+  fs.appendFileSync(queuePath, entry, 'utf-8');
+  return true;
+}
+
+export function readQueue(projectDir) {
+  const queuePath = path.join(projectDir, QUEUE_FILE);
+  if (!fs.existsSync(queuePath)) return [];
+  const content = fs.readFileSync(queuePath, 'utf-8');
+  const entries = [];
+  const sections = content.split(/^## /m).filter(Boolean);
+  for (const section of sections) {
+    if (section.startsWith('#') || section.startsWith('Skill Queue')) continue;
+    const lines = section.split('\n');
+    const header = lines[0];
+    const props = {};
+    for (const line of lines.slice(1)) {
+      const match = line.match(/^- \*\*(\w+):\*\*\s*(.+)/);
+      if (match) props[match[1]] = match[2].trim();
+    }
+    if (props.status && props.status !== 'done' && props.status !== 'rejected') {
+      entries.push({
+        header,
+        ...props,
+        rawSection: section,
+      });
+    }
+  }
+  return entries;
+}
+
+export function markQueueEntryDone(projectDir, header) {
+  const queuePath = path.join(projectDir, QUEUE_FILE);
+  if (!fs.existsSync(queuePath)) return false;
+  let content = fs.readFileSync(queuePath, 'utf-8');
+  const escapedHeader = header.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const regex = new RegExp(`(- \\*\\*status:\\*\\*\\s*)(pending|pending-approval|processing)(\\n.*${escapedHeader.slice(0, 30)})`, 's');
+  content = content.replace(
+    new RegExp(`## ${escapedHeader.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'g'),
+    `## ${header}`
+  );
+  const entryRegex = new RegExp(
+    `## ${escapedHeader}[^#]*?- \\*\\*status:\\*\\*\\s*\\w+`,
+    's'
+  );
+  content = content.replace(
+    entryRegex,
+    (match) => match.replace(/- \*\*status:\*\*\s*\w+/, `- **status:** done`)
+  );
+  fs.writeFileSync(queuePath, content, 'utf-8');
+  return true;
+}
+
+export { QUEUE_FILE, INDEX_FILE };