bananahub 0.1.0

package/lib/commands/info.js

@@ -0,0 +1,74 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TEMPLATES_DIR, SOURCE_FILE } from '../constants.js';
+import { parseFrontmatter } from '../frontmatter.js';
+import { bold, dim, cyan, green } from '../color.js';
+import { red } from '../color.js';
+
+export async function infoCommand(args) {
+  const id = args[0];
+  if (!id) {
+    console.error(red('Usage: bananahub info <template-id>'));
+    process.exit(1);
+  }
+
+  let content;
+  try {
+    content = await readFile(join(TEMPLATES_DIR, id, 'template.md'), 'utf8');
+  } catch {
+    console.error(red(`Template "${id}" is not installed.`));
+    process.exit(1);
+  }
+
+  const fm = parseFrontmatter(content);
+  if (!fm) {
+    console.error(red('Could not parse template frontmatter.'));
+    process.exit(1);
+  }
+
+  let source = null;
+  try {
+    const raw = await readFile(join(TEMPLATES_DIR, id, SOURCE_FILE), 'utf8');
+    source = JSON.parse(raw);
+  } catch { /* ok */ }
+
+  console.log(bold(`\n  ${fm.title || id}`));
+  if (fm.title_en) console.log(dim(`  ${fm.title_en}`));
+  console.log();
+
+  const fields = [
+    ['ID', fm.id || id],
+    ['Type', fm.type || 'prompt'],
+    ['Version', fm.version || '-'],
+    ['Author', fm.author || '-'],
+    ['Profile', fm.profile || '-'],
+    ['Aspect', fm.aspect || '-'],
+    ['Difficulty', fm.difficulty || '-'],
+  ];
+
+  for (const [k, v] of fields) {
+    console.log(`  ${cyan(k.padEnd(12))} ${v}`);
+  }
+
+  if (fm.tags?.length) {
+    console.log(`  ${cyan('Tags'.padEnd(12))} ${fm.tags.join(', ')}`);
+  }
+
+  if (fm.models?.length) {
+    console.log(`  ${cyan('Models'.padEnd(12))}`);
+    for (const m of fm.models) {
+      const name = m.name || m;
+      const quality = m.quality ? ` (${m.quality})` : '';
+      console.log(`    - ${name}${dim(quality)}`);
+    }
+  }
+
+  if (source) {
+    console.log();
+    console.log(dim(`  Source: ${source.repo}`));
+    console.log(dim(`  Installed: ${source.installed_at}`));
+    if (source.sha) console.log(dim(`  SHA: ${source.sha.slice(0, 8)}`));
+  }
+
+  console.log(green(`\n  Use: /nanobanana use ${id}\n`));
+}

package/lib/commands/init.js

@@ -0,0 +1,214 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { VALID_PROFILES, VALID_DIFFICULTIES, VALID_TEMPLATE_TYPES } from '../constants.js';
+import { bold, green, cyan, dim } from '../color.js';
+
+async function collectInput(typeHint) {
+  if (process.stdin.isTTY) {
+    return collectInteractive(typeHint);
+  }
+  return collectPiped(typeHint);
+}
+
+async function collectInteractive(typeHint) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+
+  try {
+    let type = typeHint || 'prompt';
+    if (!typeHint) {
+      console.log(dim(`  Template types: ${VALID_TEMPLATE_TYPES.join(', ')}`));
+      type = (await ask(cyan('  Type: '))).trim() || 'prompt';
+      if (!VALID_TEMPLATE_TYPES.includes(type)) {
+        console.log(dim(`  Using "prompt" (invalid type: "${type}")`));
+        type = 'prompt';
+      }
+    }
+
+    const id = (await ask(cyan('  Template ID (lowercase, hyphens): '))).trim().toLowerCase().replace(/\s+/g, '-') || 'my-template';
+    const title = (await ask(cyan('  Title (Chinese): '))).trim() || '我的模板';
+    const titleEn = (await ask(cyan('  Title (English): '))).trim() || 'My Template';
+
+    console.log(dim(`  Profiles: ${VALID_PROFILES.join(', ')}`));
+    let profile = (await ask(cyan('  Profile: '))).trim() || 'general';
+    if (!VALID_PROFILES.includes(profile)) {
+      console.log(dim(`  Using "general" (invalid profile: "${profile}")`));
+      profile = 'general';
+    }
+
+    console.log(dim(`  Levels: ${VALID_DIFFICULTIES.join(', ')}`));
+    let difficulty = (await ask(cyan('  Difficulty: '))).trim() || 'beginner';
+    if (!VALID_DIFFICULTIES.includes(difficulty)) difficulty = 'beginner';
+
+    return { type, id, title, titleEn, profile, difficulty };
+  } finally {
+    rl.close();
+  }
+}
+
+async function collectPiped(typeHint) {
+  const lines = [];
+  const rl = createInterface({ input: process.stdin, terminal: false });
+  for await (const line of rl) {
+    lines.push(line.trim());
+  }
+
+  const pipedType = VALID_TEMPLATE_TYPES.includes(lines[0]) ? lines[0] : null;
+  const offset = pipedType ? 1 : 0;
+
+  return {
+    type: VALID_TEMPLATE_TYPES.includes(typeHint) ? typeHint : (pipedType || 'prompt'),
+    id: (lines[offset] || 'my-template').toLowerCase().replace(/\s+/g, '-'),
+    title: lines[offset + 1] || '我的模板',
+    titleEn: lines[offset + 2] || 'My Template',
+    profile: VALID_PROFILES.includes(lines[offset + 3]) ? lines[offset + 3] : 'general',
+    difficulty: VALID_DIFFICULTIES.includes(lines[offset + 4]) ? lines[offset + 4] : 'beginner'
+  };
+}
+
+function buildTemplateBody(type) {
+  if (type === 'workflow') {
+    return `## Goal
+
+Describe the workflow outcome this template should help the agent produce.
+
+## When To Use
+
+- Describe the situations where this workflow is a strong fit
+
+## Inputs
+
+| Input | Required | Description |
+|-------|----------|-------------|
+| \`input_name\` | yes | What the agent needs before starting |
+
+## Steps
+
+1. Describe the first step the agent should take.
+2. Describe the next decision or generation step.
+3. Describe how to iterate or stop.
+
+## Prompt Blocks
+
+### Starter Prompt
+
+\`\`\`text
+Reusable prompt block or instruction fragment for this workflow
+\`\`\`
+
+## Success Checks
+
+- Add checks that confirm the workflow result is usable
+`;
+  }
+
+  return `## Prompt Template
+
+\`\`\`
+Your prompt here with {{variable|default value}} slots
+\`\`\`
+
+## Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| \`variable\` | default value | Description |
+
+## Tips
+
+- Add tips for using this template
+`;
+}
+
+function buildReadme(titleEn, id, profile, type) {
+  return `# ${titleEn}
+
+A Nanobanana ${type} template for ${profile} workflows.
+
+## Install
+
+\`\`\`bash
+npx bananahub add your-username/${id}
+\`\`\`
+
+## Verified Models
+
+- \`gemini-3-pro-image-preview\` — validate the primary flow with a real sample before publishing
+
+## Supported Models
+
+- \`gemini-3.1-flash-image-preview\` — expected to work, not yet manually verified
+
+## Sample Outputs
+
+| File | Model | Prompt / Variant |
+|---|---|---|
+| \`samples/sample-3-pro-01.png\` | \`gemini-3-pro-image-preview\` | Replace with your real sample or representative workflow output |
+
+Update this README after you generate real samples. Each sample filename should include the generating model shorthand, for example \`sample-3-pro-01.png\` or \`sample-3.1-flash-01.png\`.
+`;
+}
+
+export async function initCommand(args) {
+  console.log(bold('\n  BananaHub Template Scaffolding\n'));
+
+  const typeFlag = args.indexOf('--type');
+  const typeHint = typeFlag !== -1 ? args[typeFlag + 1] : null;
+  if (typeHint && !VALID_TEMPLATE_TYPES.includes(typeHint)) {
+    throw new Error(`Invalid template type: ${typeHint}`);
+  }
+
+  const { type, id, title, titleEn, profile, difficulty } = await collectInput(typeHint);
+
+  const outDir = join(process.cwd(), id);
+  await mkdir(join(outDir, 'samples'), { recursive: true });
+
+  const sampleFrontmatter = type === 'prompt' ? `samples:
+  - file: samples/sample-3-pro-01.png
+    model: gemini-3-pro-image-preview
+    prompt: "The exact prompt used to generate this sample"
+    aspect: "16:9"` : `samples: []`;
+
+  const templateMd = `---
+type: ${type}
+id: ${id}
+title: ${title}
+title_en: ${titleEn}
+author: your-github-username
+version: 1.0.0
+profile: ${profile}
+tags: []
+models:
+  - name: gemini-3-pro-image-preview
+    tested: true
+    quality: best
+  - name: gemini-3.1-flash-image-preview
+    tested: false
+    quality: good
+aspect: "16:9"
+difficulty: ${difficulty}
+${sampleFrontmatter}
+created: ${new Date().toISOString().split('T')[0]}
+updated: ${new Date().toISOString().split('T')[0]}
+---
+
+${buildTemplateBody(type)}
+`;
+
+  await writeFile(join(outDir, 'template.md'), templateMd);
+  await writeFile(join(outDir, 'samples', '.gitkeep'), '');
+  await writeFile(join(outDir, 'README.md'), buildReadme(titleEn, id, profile, type));
+
+  console.log(green(`\n  Created: ${bold(id)}/`));
+  console.log(dim(`    ${id}/template.md`));
+  console.log(dim(`    ${id}/samples/.gitkeep`));
+  console.log(dim(`    ${id}/README.md`));
+  console.log(cyan('\n  Next steps:'));
+  console.log(dim(`    1. Edit template.md — add your ${type === 'workflow' ? 'workflow sections and prompt blocks' : 'prompt and variables'}`));
+  console.log(dim('    2. Add sample images to samples/ and include the model in each filename'));
+  console.log(dim('    3. Update README.md with verified/supported models and sample mappings'));
+  console.log(dim('    4. Create a GitHub repo and push'));
+  console.log(dim('    5. Others install: npx bananahub add <user>/' + id));
+  console.log();
+}

package/lib/commands/list.js

@@ -0,0 +1,38 @@
+import { loadRegistry } from '../registry.js';
+import { bold, dim, cyan, yellow } from '../color.js';
+
+export async function listCommand() {
+  const registry = await loadRegistry();
+  const templates = registry.templates || [];
+
+  if (templates.length === 0) {
+    console.log(dim('\n  No templates installed.'));
+    console.log(dim('  Install one: bananahub add <user/repo>\n'));
+    return;
+  }
+
+  // Group by profile
+  const groups = {};
+  for (const t of templates) {
+    const profile = t.profile || 'general';
+    if (!groups[profile]) groups[profile] = [];
+    groups[profile].push(t);
+  }
+
+  console.log(bold(`\n  Installed Templates (${templates.length})\n`));
+
+  for (const [profile, items] of Object.entries(groups).sort()) {
+    console.log(cyan(`  [${profile}]`));
+    for (const t of items) {
+      const title = t.title_en || t.title || t.id;
+      const type = dim(` [${t.type || 'prompt'}]`);
+      const version = t.version ? dim(` v${t.version}`) : '';
+      const author = t.author ? dim(` by ${t.author}`) : '';
+      console.log(`    ${bold(t.id)}${type}  ${title}${version}${author}`);
+      if (t.tags?.length) {
+        console.log(dim(`      Tags: ${t.tags.join(', ')}`));
+      }
+    }
+    console.log();
+  }
+}

package/lib/commands/registry-cmd.js

@@ -0,0 +1,15 @@
+import { rebuildRegistry } from '../registry.js';
+import { bold, green, dim } from '../color.js';
+
+export async function registryCommand(args) {
+  const sub = args[0];
+  if (sub !== 'rebuild') {
+    console.log(`  Usage: bananahub registry rebuild`);
+    process.exit(1);
+  }
+
+  console.log(dim('  Rebuilding registry...'));
+  const registry = await rebuildRegistry();
+  const count = registry.templates?.length || 0;
+  console.log(green(`  Registry rebuilt: ${bold(String(count))} template(s) indexed.\n`));
+}

package/lib/commands/remove.js

@@ -0,0 +1,25 @@
+import { rm, access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TEMPLATES_DIR } from '../constants.js';
+import { rebuildRegistry } from '../registry.js';
+import { bold, green, red } from '../color.js';
+
+export async function removeCommand(args) {
+  const id = args[0];
+  if (!id) {
+    console.error(red('Usage: bananahub remove <template-id>'));
+    process.exit(1);
+  }
+
+  const dir = join(TEMPLATES_DIR, id);
+  try {
+    await access(dir);
+  } catch {
+    console.error(red(`Template "${id}" is not installed.`));
+    process.exit(1);
+  }
+
+  await rm(dir, { recursive: true, force: true });
+  await rebuildRegistry();
+  console.log(green(`  Removed: ${bold(id)}`));
+}

package/lib/commands/search.js

@@ -0,0 +1,277 @@
+import { bold, cyan, dim, green, red, yellow } from '../color.js';
+import { fetchHubCatalog, fetchHubTrending, buildCatalogLookup, compareCatalogPriority, templateKey } from '../hub.js';
+import { HUB_SITE } from '../constants.js';
+
+export async function searchCommand(args) {
+  const options = parseSearchArgs(args);
+  const keyword = options.terms.join(' ').trim();
+
+  if (!keyword) {
+    console.error(red('Usage: bananahub search <keyword> [--limit N] [--curated|--discovered]'));
+    process.exit(1);
+  }
+
+  let catalog;
+  try {
+    catalog = await fetchHubCatalog();
+  } catch (error) {
+    console.error(red(`Error: ${error.message}`));
+    console.log(dim(`Browse the hub directly: ${HUB_SITE}`));
+    process.exit(1);
+  }
+
+  const matches = rankTemplates(catalog.templates || [], keyword, options).slice(0, options.limit);
+
+  if (matches.length === 0) {
+    console.log(yellow(`\n  No hub templates matched "${keyword}".`));
+    console.log(dim(`  Browse the full catalog: ${HUB_SITE}\n`));
+    return;
+  }
+
+  const sourceHint = options.source === 'all' ? '' : dim(` (${options.source})`);
+  console.log(bold(`\n  Hub Search Results${sourceHint}\n`));
+
+  for (const [index, template] of matches.entries()) {
+    printTemplateResult(index + 1, template);
+  }
+
+  console.log(green('  Install with: bananahub add <install_target>\n'));
+}
+
+export async function trendingCommand(args = []) {
+  const options = parseTrendingArgs(args);
+  if (!['24h', '7d'].includes(options.period)) {
+    console.error(red('Usage: bananahub trending [--period 24h|7d] [--limit N]'));
+    process.exit(1);
+  }
+
+  let catalog;
+  let trending;
+
+  try {
+    [catalog, trending] = await Promise.all([
+      fetchHubCatalog(),
+      fetchHubTrending({ period: options.period, limit: options.limit })
+    ]);
+  } catch (error) {
+    console.error(red(`Error: ${error.message}`));
+    console.log(dim(`Browse the hub directly: ${HUB_SITE}`));
+    process.exit(1);
+  }
+
+  const lookup = buildCatalogLookup(catalog);
+  const items = trending.templates || [];
+
+  if (items.length === 0) {
+    console.log(yellow(`\n  No trending installs found for ${options.period}.\n`));
+    return;
+  }
+
+  console.log(bold(`\n  Trending Templates (${options.period})\n`));
+
+  for (const [index, item] of items.entries()) {
+    const template = lookup.get(templateKey(item.repo, item.template_id));
+    printTrendingResult(index + 1, item, template);
+  }
+
+  console.log(green('  Install with: bananahub add <install_target>\n'));
+}
+
+function parseSearchArgs(args) {
+  const options = {
+    terms: [],
+    limit: 8,
+    source: 'all'
+  };
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === '--limit') {
+      options.limit = clampLimit(args[index + 1], 8, 20);
+      index++;
+      continue;
+    }
+    if (arg === '--curated') {
+      options.source = 'curated';
+      continue;
+    }
+    if (arg === '--discovered') {
+      options.source = 'discovered';
+      continue;
+    }
+    options.terms.push(arg);
+  }
+
+  return options;
+}
+
+function parseTrendingArgs(args) {
+  const options = {
+    limit: 10,
+    period: '7d'
+  };
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === '--limit') {
+      options.limit = clampLimit(args[index + 1], 10, 20);
+      index++;
+      continue;
+    }
+    if (arg === '--period') {
+      options.period = args[index + 1] || '';
+      index++;
+    }
+  }
+
+  return options;
+}
+
+function rankTemplates(templates, keyword, options) {
+  const query = normalize(keyword);
+  const terms = buildTerms(query);
+
+  return templates
+    .filter((template) => options.source === 'all' || template.catalog_source === options.source)
+    .map((template) => ({
+      template,
+      score: scoreTemplate(template, query, terms)
+    }))
+    .filter((entry) => entry.score > 0)
+    .sort((left, right) => {
+      const scoreDiff = right.score - left.score;
+      if (scoreDiff !== 0) {
+        return scoreDiff;
+      }
+      return compareCatalogPriority(left.template, right.template);
+    })
+    .map((entry) => entry.template);
+}
+
+function scoreTemplate(template, query, terms) {
+  const id = normalize(template.id);
+  const title = normalize(template.title);
+  const titleEn = normalize(template.title_en);
+  const description = normalize(template.description);
+  const profile = normalize(template.profile);
+  const tags = (template.tags || []).map((tag) => normalize(tag));
+
+  let relevance = 0;
+
+  if (id === query) relevance += 100;
+  if (title === query || titleEn === query) relevance += 80;
+  if (tags.includes(query)) relevance += 60;
+
+  if (id.includes(query)) relevance += 24;
+  if (title.includes(query) || titleEn.includes(query)) relevance += 24;
+  if (description.includes(query)) relevance += 12;
+  if (profile.includes(query)) relevance += 8;
+
+  for (const term of terms) {
+    if (term === query) continue;
+    if (tags.includes(term)) relevance += 10;
+    if (tags.some((tag) => tag.includes(term))) relevance += 6;
+    if (id.includes(term)) relevance += 5;
+    if (title.includes(term) || titleEn.includes(term)) relevance += 5;
+    if (description.includes(term)) relevance += 2;
+    if (profile.includes(term)) relevance += 2;
+  }
+
+  if (relevance === 0) {
+    return 0;
+  }
+
+  let score = relevance;
+  if (template.pinned) score += 12;
+  if (template.featured) score += 8;
+  if (template.catalog_source === 'curated') score += 4;
+  if (template.official) score += 2;
+
+  return score;
+}
+
+function buildTerms(query) {
+  const parts = query
+    .split(/\s+/)
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .filter((part) => part.length > 1 || /[^\u0000-\u007f]/.test(part));
+
+  if (query && !parts.includes(query)) {
+    parts.unshift(query);
+  }
+
+  return [...new Set(parts)];
+}
+
+function normalize(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function printTemplateResult(index, template) {
+  const title = template.title_en || template.title || template.id;
+  const subtitle = template.title && template.title_en ? template.title : '';
+  const flags = buildFlags(template);
+
+  console.log(`  ${cyan(String(index).padStart(2, ' '))}. ${bold(template.id)}${dim(` [${template.type || 'prompt'}]`)}  ${title}`);
+  if (subtitle) {
+    console.log(dim(`      ${subtitle}`));
+  }
+  console.log(dim(`      ${template.profile || 'general'} | ${template.difficulty || 'beginner'}${flags ? ` | ${flags}` : ''}`));
+  if (template.description) {
+    console.log(dim(`      ${clip(template.description, 140)}`));
+  }
+  if (template.tags?.length) {
+    console.log(dim(`      Tags: ${template.tags.slice(0, 6).join(', ')}`));
+  }
+  if (template.install_cmd) {
+    console.log(dim(`      Install: ${template.install_cmd}`));
+  }
+  console.log();
+}
+
+function printTrendingResult(index, item, template) {
+  const id = template?.id || item.template_id;
+  const type = template?.type || 'template';
+  const title = template?.title_en || template?.title || id;
+  const subtitle = template?.title && template?.title_en ? template.title : '';
+  const flags = buildFlags(template);
+  const installCmd = template?.install_cmd || `bananahub add ${item.repo}`;
+
+  console.log(`  ${cyan(String(index).padStart(2, ' '))}. ${bold(id)}${dim(` [${type}]`)}  ${title}`);
+  if (subtitle) {
+    console.log(dim(`      ${subtitle}`));
+  }
+  console.log(dim(`      ${item.installs} installs | ${item.repo}${flags ? ` | ${flags}` : ''}`));
+  console.log(dim(`      Install: ${installCmd}`));
+  console.log();
+}
+
+function buildFlags(template) {
+  if (!template) {
+    return '';
+  }
+
+  const flags = [];
+  if (template.catalog_source) flags.push(template.catalog_source);
+  if (template.official) flags.push('official');
+  if (template.pinned) flags.push('pinned');
+  if (template.featured) flags.push('featured');
+  return flags.join(', ');
+}
+
+function clip(text, maxLength) {
+  const value = String(text || '').trim();
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength - 3)}...`;
+}
+
+function clampLimit(rawValue, fallback, max) {
+  const parsed = parseInt(rawValue || String(fallback), 10);
+  if (Number.isNaN(parsed) || parsed < 1) {
+    return fallback;
+  }
+  return Math.min(parsed, max);
+}

package/lib/commands/update.js

@@ -0,0 +1,48 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TEMPLATES_DIR, SOURCE_FILE } from '../constants.js';
+import { loadRegistry } from '../registry.js';
+import { addCommand } from './add.js';
+import { bold, dim, yellow, green, red } from '../color.js';
+
+export async function updateCommand(args) {
+  const targetId = args[0];
+  const registry = await loadRegistry();
+  const templates = registry.templates || [];
+
+  if (templates.length === 0) {
+    console.log(dim('  No templates installed.'));
+    return;
+  }
+
+  let toUpdate = templates;
+  if (targetId) {
+    toUpdate = templates.filter((template) => template.id === targetId);
+    if (toUpdate.length === 0) {
+      console.error(red(`Template "${targetId}" is not installed.`));
+      process.exit(1);
+    }
+  }
+
+  for (const template of toUpdate) {
+    let source;
+    try {
+      const raw = await readFile(join(TEMPLATES_DIR, template.id, SOURCE_FILE), 'utf8');
+      source = JSON.parse(raw);
+    } catch {
+      console.log(yellow(`  Skipping ${bold(template.id)}: no source info (locally created?)`));
+      continue;
+    }
+
+    const installTarget = source.install_target || (source.template_path ? `${source.repo}/${source.template_path}` : source.repo);
+    if (!installTarget) {
+      console.log(yellow(`  Skipping ${bold(template.id)}: no source repo recorded`));
+      continue;
+    }
+
+    console.log(dim(`  Updating ${bold(template.id)} from ${installTarget}...`));
+    await addCommand([installTarget]);
+  }
+
+  console.log(green('\n  Update complete.\n'));
+}