growgami-skills 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Growgami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# Growgami Skills
+
+Claude Code skills built from real operational experience.
+
+## Install
+
+**With npx (quickest):**
+
+```bash
+npx growgami-skills --all                  # everything
+npx growgami-skills --list                 # list available skills (and bundles)
+npx growgami-skills org-map                # specific skill(s)
+npx growgami-skills neobank-seo-skills     # a whole bundle (all 6 SEO skills)
+```
+
+Installing a bundle name (e.g. `neobank-seo-skills`) installs every skill inside
+it, each under its own bare name.
+
+Installs into `~/.claude/skills/` (override with `CLAUDE_SKILLS_DIR`).
+
+**Alternative — git clone + install script:**
+
+```bash
+git clone https://github.com/growgami/skills.git
+cd skills
+./install.sh              # interactive picker
+./install.sh org-map      # specific skill
+./install.sh --all        # everything
+```
+
+**Alternative — git clone + manual copy:**
+
+```bash
+git clone https://github.com/growgami/skills.git
+cp -r skills/skills/org-map ~/.claude/skills/   # one skill
+cp -r skills/skills/* ~/.claude/skills/         # all flat skills
+```
+
+## Skills
+
+| Skill | What it does |
+|---|---|
+| [org-map](skills/org-map/) | Map your org's real operating model into a structured YAML ontology |
+| [brand-guidelines](skills/brand-guidelines/) | Brand color and typography standards |
+| [competitive-ads-extractor](skills/competitive-ads-extractor/) | Competitive ad intelligence extraction |
+| [editor](skills/editor/) | Content editing |
+| [frontend-design](skills/frontend-design/) | Frontend UI/UX design |
+| [investor-materials](skills/investor-materials/) | Investor decks and materials |
+| [lead-research-assistant](skills/lead-research-assistant/) | Lead research and qualification |
+| [market-research-reports](skills/market-research-reports/) | Market research generation |
+| [memory-management](skills/memory-management/) | Claude memory management |
+| [neobank-lifecycle-sequence-generator](skills/neobank-lifecycle-sequence-generator/) | Neobank lifecycle sequences |
+| [skill-creator](skills/skill-creator/) | Scaffold new Claude skills |
+| [neobank-seo-skills](skills/neobank-seo-skills/) | Bundle of 6 nested SEO skills for neobank/fintech: seo-audit, ai-seo, programmatic-seo, competitor-pages, schema, aso |
+
+## Structure
+
+```
+skills/
+  skill-name/
+    SKILL.md        # skill definition (YAML frontmatter + prompt)
+    references/     # optional supporting files
+  bundle-name/      # a bundle groups related skills
+    skills/
+      skill-name/
+        SKILL.md
+        references/
+```
+
+Both flat skills and nested bundle skills install under their bare name (e.g. `seo-audit`). Tooling discovers SKILL.md at both depths.
+
+Compatible with vanilla Claude Code (`~/.claude/skills/`) and [skills.ws](https://skills.ws).

package/bin/cli.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+'use strict';
+
+const { discover } = require('../lib/discover');
+const { targetDir, installSkill } = require('../lib/install');
+const { printList, interactivePick } = require('../lib/ui');
+
+const dim = '\x1b[2m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const red = '\x1b[31m';
+const reset = '\x1b[0m';
+
+function printHelp(target) {
+  process.stdout.write('Usage: growgami-skills [--all | skill1 skill2 ...]\n');
+  process.stdout.write('\n');
+  process.stdout.write('  --all         Install all skills\n');
+  process.stdout.write('  --list        List available skills\n');
+  process.stdout.write('  skill1 ...    Install specific skills\n');
+  process.stdout.write('  (no args)     Interactive picker\n');
+  process.stdout.write('\n');
+  process.stdout.write(
+    `Target: ${target} (override with CLAUDE_SKILLS_DIR)\n`
+  );
+}
+
+// Install one resolved skill, printing a "+ name" line on success.
+// Returns 0 on success, 1 on failure.
+function installOne(skill, target) {
+  try {
+    installSkill(skill.name, skill.srcPath, target);
+    process.stdout.write(`  ${green}+${reset} ${skill.name}\n`);
+    return 0;
+  } catch (err) {
+    process.stdout.write(
+      `  ${red}skip${reset} ${skill.name} (${err.message})\n`
+    );
+    return 1;
+  }
+}
+
+// Install a set of bare names, resolving each against discovered skills and
+// bundles. A bundle name installs all of its member skills.
+// Returns a non-zero exit code if any name is missing or collides.
+function installNames(names, skills, bundles, collisions, target) {
+  const byName = new Map(skills.map((s) => [s.name, s]));
+  const byBundle = new Map(bundles.map((b) => [b.name, b]));
+  const collisionNames = new Set(collisions.map((c) => c.name));
+  let status = 0;
+
+  for (const name of names) {
+    if (collisionNames.has(name)) {
+      process.stdout.write(
+        `  ${red}skip${reset} ${name} (name collision)\n`
+      );
+      status = 1;
+      continue;
+    }
+    const skill = byName.get(name);
+    const bundle = byBundle.get(name);
+    // Prefer an individual skill over a bundle if both somehow match.
+    if (skill) {
+      if (bundle) {
+        process.stdout.write(
+          `  ${yellow}note${reset} ${name} matches both a skill and a bundle; installing the skill\n`
+        );
+      }
+      status = installOne(skill, target) || status;
+      continue;
+    }
+    if (bundle) {
+      process.stdout.write(
+        `  ${dim}bundle ${bundle.name} -> ${bundle.members.length} skills${reset}\n`
+      );
+      for (const member of bundle.members) {
+        const memberSkill = byName.get(member);
+        if (!memberSkill) {
+          process.stdout.write(
+            `  ${yellow}skip${reset} ${member} (not found)\n`
+          );
+          status = 1;
+          continue;
+        }
+        status = installOne(memberSkill, target) || status;
+      }
+      continue;
+    }
+    process.stdout.write(`  ${yellow}skip${reset} ${name} (not found)\n`);
+    status = 1;
+  }
+  return status;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const target = targetDir();
+  const { skills, bundles, collisions } = discover();
+
+  if (args[0] === '--help' || args[0] === '-h') {
+    printHelp(target);
+    return 0;
+  }
+
+  if (args[0] === '--list') {
+    for (const c of collisions) {
+      process.stderr.write(
+        `  ${red}skip${reset} ${c.name} (name collision)\n`
+      );
+    }
+    printList(skills, bundles);
+    return 0;
+  }
+
+  process.stdout.write(`\n  ${dim}Installing to ${target}${reset}\n\n`);
+
+  let names;
+  if (args[0] === '--all') {
+    names = skills.map((s) => s.name);
+  } else if (args.length > 0) {
+    names = args;
+  } else if (process.stdin.isTTY) {
+    names = await interactivePick(skills, bundles);
+  } else {
+    printHelp(target);
+    return 0;
+  }
+
+  const status = installNames(names, skills, bundles, collisions, target);
+  process.stdout.write('\n');
+  return status;
+}
+
+main()
+  .then((code) => process.exit(code))
+  .catch((err) => {
+    process.stderr.write(`${err && err.stack ? err.stack : err}\n`);
+    process.exit(1);
+  });

package/lib/discover.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Root of this package (parent of lib/).
+const PKG_ROOT = path.join(__dirname, '..');
+const SKILLS_DIR = path.join(PKG_ROOT, 'skills');
+
+function isSkillDir(dir) {
+  return fs.existsSync(path.join(dir, 'SKILL.md'));
+}
+
+function listSubdirs(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => path.join(dir, e.name));
+}
+
+/**
+ * Walk skills/ for skills at two depths:
+ *   - Flat:   skills/<name>/SKILL.md
+ *   - Nested: skills/<bundle>/skills/<name>/SKILL.md
+ *
+ * A directory counts as a skill only if it contains SKILL.md. A bundle's own
+ * top-level README.md (with no SKILL.md) is never treated as a skill.
+ *
+ * A bundle = a directory directly under skills/ with NO SKILL.md of its own
+ * that contains a skills/ subdirectory holding one or more <name>/SKILL.md.
+ * Its members are those nested skills.
+ *
+ * Returns an object:
+ *   { skills: Array<{ name, srcPath }>,
+ *     bundles: Array<{ name, members: [skillName, ...] }>,
+ *     collisions: Array<{ name, paths }> }
+ * `skills` contains each bare name once (first source wins); any bare name
+ * resolving to more than one source is reported in `collisions`.
+ */
+function discover() {
+  const found = []; // { name, srcPath }
+  const bundles = []; // { name, members: [skillName, ...] }
+
+  for (const top of listSubdirs(SKILLS_DIR)) {
+    if (isSkillDir(top)) {
+      found.push({ name: path.basename(top), srcPath: top });
+      continue;
+    }
+    const nestedSkillsDir = path.join(top, 'skills');
+    if (fs.existsSync(nestedSkillsDir)) {
+      const members = [];
+      for (const nested of listSubdirs(nestedSkillsDir)) {
+        if (isSkillDir(nested)) {
+          const memberName = path.basename(nested);
+          found.push({ name: memberName, srcPath: nested });
+          members.push(memberName);
+        }
+      }
+      if (members.length > 0) {
+        bundles.push({ name: path.basename(top), members });
+      }
+    }
+  }
+
+  const byName = new Map();
+  for (const item of found) {
+    if (!byName.has(item.name)) byName.set(item.name, []);
+    byName.get(item.name).push(item.srcPath);
+  }
+
+  const skills = [];
+  const collisions = [];
+  for (const [name, paths] of byName) {
+    if (paths.length > 1) {
+      collisions.push({ name, paths });
+    }
+    skills.push({ name, srcPath: paths[0] });
+  }
+
+  skills.sort((a, b) => a.name.localeCompare(b.name));
+  bundles.sort((a, b) => a.name.localeCompare(b.name));
+  return { skills, bundles, collisions };
+}
+
+module.exports = { discover, SKILLS_DIR };

package/lib/install.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function targetDir() {
+  return (
+    process.env.CLAUDE_SKILLS_DIR ||
+    path.join(os.homedir(), '.claude', 'skills')
+  );
+}
+
+/**
+ * Copy a single skill's entire source directory (including references/) into
+ * <target>/<name>/ recursively. Replaces any existing install of that name.
+ */
+function installSkill(name, srcPath, target) {
+  const dest = path.join(target, name);
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.mkdirSync(dest, { recursive: true });
+  fs.cpSync(srcPath, dest, { recursive: true });
+}
+
+module.exports = { targetDir, installSkill };

package/lib/ui.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const readline = require('readline');
+
+function printList(skills, bundles) {
+  for (const s of skills) {
+    process.stdout.write(s.name + '\n');
+  }
+  if (bundles && bundles.length > 0) {
+    process.stdout.write('\nBundles (install the whole set by name):\n');
+    for (const b of bundles) {
+      process.stdout.write(`  ${b.name}  (${b.members.join(', ')})\n`);
+    }
+  }
+}
+
+/**
+ * Interactive numbered picker. Resolves with an array of selected bare names
+ * (raw strings; the caller validates them against discovered skills).
+ * Accepts comma-separated numbers and/or names, or "all".
+ */
+function interactivePick(skills, bundles) {
+  return new Promise((resolve) => {
+    process.stdout.write('  Available skills:\n\n');
+    skills.forEach((s, i) => {
+      const n = String(i + 1).padStart(2, ' ');
+      process.stdout.write(`  ${n}) ${s.name}\n`);
+    });
+    if (bundles && bundles.length > 0) {
+      process.stdout.write('\n  Bundles (install the whole set by name):\n');
+      for (const b of bundles) {
+        process.stdout.write(`    ${b.name}  (${b.members.join(', ')})\n`);
+      }
+    }
+    process.stdout.write('\n');
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(
+      "  Enter numbers or names (comma-separated), or 'all': ",
+      (answer) => {
+        rl.close();
+        const choice = answer.trim();
+        if (choice === 'all') {
+          resolve(skills.map((s) => s.name));
+          return;
+        }
+        const picks = choice
+          .split(',')
+          .map((p) => p.trim())
+          .filter((p) => p.length > 0)
+          .map((p) => {
+            if (/^[0-9]+$/.test(p)) {
+              const idx = parseInt(p, 10) - 1;
+              if (idx >= 0 && idx < skills.length) return skills[idx].name;
+            }
+            return p;
+          });
+        resolve(picks);
+      }
+    );
+  });
+}
+
+module.exports = { printList, interactivePick };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "growgami-skills",
+  "version": "0.1.3",
+  "description": "Claude Code skills built from real operational experience, installable via npx.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "github:growgami/skills"
+  },
+  "bin": {
+    "growgami-skills": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "skills/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "commonjs"
+}

package/skills/brand-guidelines/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: brand-guidelines
+description: Applies Growgami's official brand colors and typography to any artifact that may benefit from having Growgami's look-and-feel. Use when brand colors or style guidelines, visual formatting, or company design standards apply.
+---
+
+# Growgami Brand Styling
+
+## Overview
+
+Use this skill to apply Growgami's official brand identity to any visual or written artifact.
+
+**Keywords**: branding, corporate identity, visual identity, styling, brand colors, typography, Growgami brand, visual formatting, visual design
+
+## Brand Guidelines
+
+### Colors
+
+Growgami uses a monochromatic grayscale palette with no accent colors.
+
+**Dark Scale (Near Black):**
+
+| Name       | Hex       | Use                          |
+|------------|-----------|------------------------------|
+| Near Black | `#080808` | Primary backgrounds, darkest |
+|            | `#141414` | Dark surfaces                |
+|            | `#1F1F1F` | Elevated dark surfaces       |
+|            | `#292929` | Borders on dark              |
+|            | `#333333` | Subtle dark elements         |
+
+**Light Scale (White Smoke):**
+
+| Name        | Hex       | Use                           |
+|-------------|-----------|-------------------------------|
+|             | `#D6D6D6` | Subtle borders on light       |
+|             | `#E0E0E0` | Muted backgrounds             |
+|             | `#EBEBEB` | Light surfaces                |
+|             | `#F5F5F5` | Near-white backgrounds        |
+| White Smoke | `#F9F9F9` | Primary light background      |
+
+### Typography
+
+- **Headlines**: Geist Mono, Medium weight
+- **Sub Heads**: Geist Mono, Regular weight
+- **Fallback**: Monospace system font
+
+## Application Rules
+
+### Text on Dark Backgrounds
+- Use `#F9F9F9` or `#F5F5F5` for primary text
+- Use `#D6D6D6` or `#E0E0E0` for secondary/muted text
+
+### Text on Light Backgrounds
+- Use `#080808` or `#141414` for primary text
+- Use `#292929` or `#333333` for secondary/muted text
+
+### Contrast & Accessibility
+- Primary pairings: `#080808` on `#F9F9F9` or `#F9F9F9` on `#080808`
+- Avoid mid-gray on mid-gray — maintain strong contrast at all times
+
+### Font Application
+- Apply Geist Mono Medium to all headings
+- Apply Geist Mono Regular to body and sub-headings
+- Do not mix other font families — Growgami's identity is defined by Geist Mono exclusively
+
+## Technical Details
+
+### Color Application
+- Use hex values directly for web/CSS
+- For print, refer to CMYK equivalents from the Graphic Standard Manual
+- White Smoke (`#F9F9F9`) CMYK: 00/00/00/2.35
+
+### Font Management
+- Geist Mono is available via [Google Fonts](https://fonts.google.com/specimen/Geist+Mono) or as a system install
+- If unavailable, fall back to the system monospace font