@impulselab/directory 1.0.0

package/README.md

@@ -0,0 +1,144 @@
+# Impulse Directory Command Installer
+
+An NPX command that downloads prompts from Impulse Directory and installs them for Claude Desktop or Cursor.
+
+## 🚀 Installation and Usage
+
+### Direct usage with npx
+
+```bash
+npx impulse-directory <user-slug>/<command-slug> [--target <target>]
+npx impulse-directory stack <stack-id> [--target <target>]
+```
+
+`--target` selects the installation target. When omitted the command defaults to `claude-slash`.
+
+When using the `stack` command, all prompts in the stack are installed for the chosen tool. Stacks must be constrained to a specific tool to be installed via NPX.
+
+### Targets
+
+| Target | Description | Destination |
+|--------|-------------|-------------|
+| `claude-slash` | Claude slash command | `.claude/commands` (falls back to `~/.claude/commands`)
+| `claude-sub-agent` | Claude sub agent | `.claude/agents` (falls back to `~/.claude/agents`)
+| `cursor-command` | Cursor command | `.cursor/commands` (project only)
+| `cursor-rule` | Cursor rule | `.cursor/rules` (project only)
+
+> **Note**: Cursor targets require running the installer inside a Cursor project (a folder containing `.cursor/`). The command fails if no project folder is found.
+
+### Examples
+
+```bash
+# Download a Claude slash command from impulse.directory
+npx impulse-directory john/my-awesome-command
+
+# Install as a Claude sub agent
+npx impulse-directory john/my-awesome-command --target claude-sub-agent
+
+# Install as a Cursor command (inside a Cursor project)
+npx impulse-directory john/my-awesome-command --target cursor-command
+
+# Install as a Cursor rule (inside a Cursor project)
+npx impulse-directory john/my-awesome-command --target cursor-rule
+
+# Install an Impulse stack (tool-specific stack ID)
+npx impulse-directory stack 01JH0000000ABCDEF --target claude-slash
+
+# Use a custom URL (local development)
+IMPULSE_BASE_URL=localhost:3000 npx impulse-directory dev-user/dev-command
+
+# Use another server
+IMPULSE_BASE_URL=my-custom-domain.com npx impulse-directory author/custom-command
+```
+
+## 📁 Command Placement Logic
+
+### Claude targets (`claude-slash`, `claude-sub-agent`)
+
+The command searches for the `.claude` folder in the following order:
+
+1. **Current folder**: Looks for `.claude/<target>/` in the current working directory
+2. **Parent folders**: Goes up the tree to find a `.claude` folder
+3. **Fallback home**: Uses `~/.claude/<target>/` if no project folder is found
+
+This allows:
+- Installing commands at the project level (shared with the team)
+- Installing personal commands (user only)
+
+### Cursor targets (`cursor-command`, `cursor-rule`)
+
+- Must be executed inside a Cursor project (a directory containing `.cursor/`)
+- Always installs into the project `.cursor` folder
+- Fails with an explicit message if no Cursor project is detected
+
+## 🔧 Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|--------|
+| `IMPULSE_BASE_URL` | Base URL to download commands | `impulse.directory` |
+
+### Automatic HTTPS/HTTP Handling
+
+- **HTTPS by default**: All URLs use HTTPS
+- **Fallback HTTP**: If HTTPS fails, the command automatically tries HTTP
+- **Localhost auto-HTTP**: URLs containing `localhost` or `127.0.0.1` use HTTP directly
+
+## 📝 Command Format
+
+Downloaded prompts are saved as `<command-slug>.md`. Stack installs will save each command in the stack using the prompt slug (with a stack-prefixed fallback when needed).
+
+Example download URL:
+```
+https://impulse.directory/raw/user-slug/command-slug
+```
+
+Stack installation payloads are fetched from:
+
+```
+https://impulse.directory/api/stacks/<stack-id>/npx
+```
+
+## 🛠️ Development
+
+### Local Test
+
+```bash
+# From the npx/impulse-claude/ folder
+node index.js --help
+node index.js test-user/test-command
+```
+
+### File Structure
+
+```
+npx/impulse-claude/
+├── package.json    # NPM configuration
+├── index.js        # Main script
+└── README.md       # Documentation
+```
+
+## 📚 Using Downloaded Prompts
+
+- **Claude slash commands**: use `/command-name` inside Claude Desktop.
+- **Claude sub agents**: open Claude Desktop and select the agent from the agents list.
+- **Cursor commands**: trigger Cursor's command palette and run the command by name.
+- **Cursor rules**: Cursor loads rules automatically from `.cursor/rules` for the project.
+
+## 🔍 Troubleshooting
+
+### Common Errors
+
+1. **Command not found (404)**: Check the command slug
+2. **Network error**: Check your connection and the base URL
+3. **Permissions**: Make sure you have write permissions in the destination folder
+4. **Cursor project missing**: Ensure you're running the command inside a folder containing `.cursor/`
+
+### Debug
+
+To see download details:
+```bash
+# The command automatically displays the download path and destination folder
+npx impulse-directory debug-user/debug-command
+```

package/index.js

@@ -0,0 +1,608 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const os = require('os');
+
+const DEFAULT_BASE_URL = 'impulse.directory';
+const RAW_PATH = '/raw/';
+const STACK_API_PREFIX = '/api/stacks/';
+const STACK_API_SUFFIX = '/npx';
+
+function normalizeBaseHost(input) {
+	const raw = (input || '').trim();
+	if (!raw) return '';
+	let host = raw.replace(/^\s*https?:\/\//i, '');
+	host = host.replace(/\/+$/, '');
+	return host;
+}
+
+function isLocalHost(host) {
+	const hostnameOnly = (host || '').split(':')[0];
+	return (
+		hostnameOnly === 'localhost' ||
+		hostnameOnly === '127.0.0.1' ||
+		hostnameOnly === '::1'
+	);
+}
+
+function canFallbackToHttp(host) {
+	return process.env.ALLOW_HTTP_FALLBACK === '1' || isLocalHost(host);
+}
+
+const MODES = {
+  COMMAND: 'command',
+  STACK: 'stack',
+};
+
+const INSTALLATION_TARGETS = {
+  CLAUDE_SLASH: 'claude-slash',
+  CLAUDE_SUB_AGENT: 'claude-sub-agent',
+  CURSOR_COMMAND: 'cursor-command',
+  CURSOR_RULE: 'cursor-rule',
+};
+
+const DEFAULT_TARGET = INSTALLATION_TARGETS.CLAUDE_SLASH;
+
+const TARGET_CONFIG = {
+  [INSTALLATION_TARGETS.CLAUDE_SLASH]: {
+    label: 'Claude slash command',
+    description: '.claude/commands (falls back to ~/.claude/commands)',
+    resolveDirectory: () => resolveClaudeDirectory('commands'),
+    extension: '.md',
+  },
+  [INSTALLATION_TARGETS.CLAUDE_SUB_AGENT]: {
+    label: 'Claude sub agent',
+    description: '.claude/agents (falls back to ~/.claude/agents)',
+    resolveDirectory: () => resolveClaudeDirectory('agents'),
+    extension: '.md',
+  },
+  [INSTALLATION_TARGETS.CURSOR_COMMAND]: {
+    label: 'Cursor command',
+    description: '.cursor/commands (project only)',
+    resolveDirectory: () => resolveCursorDirectory('commands'),
+    extension: '.md',
+  },
+  [INSTALLATION_TARGETS.CURSOR_RULE]: {
+    label: 'Cursor rule',
+    description: '.cursor/rules (project only)',
+    resolveDirectory: () => resolveCursorDirectory('rules'),
+    extension: '.mdc',
+  },
+};
+
+const KNOWN_TARGETS = Object.keys(TARGET_CONFIG);
+
+function showHelp() {
+  console.log(`
+Impulse Claude Command Installer
+
+Usage:
+  npx impulse-directory <user-slug>/<command-slug> [--target <target>]
+  npx impulse-directory stack <stack-id>
+
+Description:
+  Downloads a command from Impulse Directory and installs it in the right tool folder.
+  When using the stack mode, installs each prompt in the stack to its inferred target.
+
+Arguments:
+  user-slug/command-slug    The full path to the command (user/command)
+  stack-id                  The stack ULID shown in the Impulse Directory UI
+
+Options:
+  --target <target>         Installation target (optional for single commands)
+  -t <target>               Short alias for --target
+  --help, -h                Show this help text
+
+Targets:
+${KNOWN_TARGETS.map((key) => {
+    const config = TARGET_CONFIG[key];
+    const defaultLabel = key === DEFAULT_TARGET ? ' (default)' : '';
+    return `  ${key.padEnd(18)} ${config.label}${defaultLabel}\n        -> ${config.description}`;
+  }).join('\n')}
+
+Environment Variables:
+  IMPULSE_BASE_URL    Base host for Impulse Directory (hostname[:port], no scheme, no trailing slash)
+                      Examples: impulse.directory | localhost:3000
+
+Examples:
+  npx impulse-directory john/my-awesome-command
+  npx impulse-directory john/my-awesome-command --target claude-sub-agent
+  npx impulse-directory john/my-awesome-command --target cursor-command
+  npx impulse-directory stack 01JH0000000ABCDEF --target claude-slash
+`);
+}
+
+function shouldUseHttps(baseUrl) {
+  if (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')) {
+    return false;
+  }
+  return true;
+}
+
+function downloadCommand(baseUrl, fullPath) {
+  return new Promise((resolve, reject) => {
+    const useHttps = shouldUseHttps(baseUrl);
+    const protocol = useHttps ? https : http;
+    const scheme = useHttps ? 'https' : 'http';
+
+    const url = `${scheme}://${baseUrl}${RAW_PATH}${fullPath}`;
+
+    protocol
+      .get(url, (res) => {
+        if (res.statusCode === 200) {
+          let data = '';
+          res.on('data', (chunk) => {
+            data += chunk;
+          });
+          res.on('end', () => resolve(data));
+        } else if (res.statusCode === 404) {
+          reject(new Error(`Command '${fullPath}' not found (404)`));
+        } else if (useHttps && (res.statusCode === 500 || res.statusCode >= 400)) {
+          if (canFallbackToHttp(baseUrl)) {
+            console.log(`HTTPS failed (${res.statusCode}), trying HTTP...`);
+            downloadWithHttp(baseUrl, fullPath)
+              .then(resolve)
+              .catch(reject);
+          } else {
+            reject(new Error(`HTTPS failed (${res.statusCode}) and HTTP fallback is disabled`));
+          }
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+        }
+      })
+      .on('error', (err) => {
+        if (useHttps) {
+          if (canFallbackToHttp(baseUrl)) {
+            console.log(`HTTPS failed (${err.message}), trying HTTP...`);
+            downloadWithHttp(baseUrl, fullPath)
+              .then(resolve)
+              .catch(reject);
+          } else {
+            reject(err);
+          }
+        } else {
+          reject(err);
+        }
+      });
+  });
+}
+
+function downloadWithHttp(baseUrl, fullPath) {
+  return new Promise((resolve, reject) => {
+    const url = `http://${baseUrl}${RAW_PATH}${fullPath}`;
+
+    console.log(`Trying HTTP: ${url}`);
+
+    http
+      .get(url, (res) => {
+        if (res.statusCode === 200) {
+          let data = '';
+          res.on('data', (chunk) => {
+            data += chunk;
+          });
+          res.on('end', () => resolve(data));
+        } else if (res.statusCode === 404) {
+          reject(new Error(`Command '${fullPath}' not found (404)`));
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+        }
+      })
+      .on('error', reject);
+  });
+}
+
+function downloadStack(baseUrl, stackId) {
+  return new Promise((resolve, reject) => {
+    const useHttps = shouldUseHttps(baseUrl);
+    const protocol = useHttps ? https : http;
+    const scheme = useHttps ? 'https' : 'http';
+    const url = `${scheme}://${baseUrl}${STACK_API_PREFIX}${stackId}${STACK_API_SUFFIX}`;
+
+    protocol
+      .get(url, (res) => {
+        if (res.statusCode === 200) {
+          let data = '';
+          res.on('data', (chunk) => {
+            data += chunk;
+          });
+          res.on('end', () => {
+            try {
+              const parsed = JSON.parse(data);
+              resolve(parsed);
+            } catch (parseError) {
+              reject(new Error('Received invalid JSON while downloading stack'));
+            }
+          });
+        } else if (res.statusCode === 404) {
+          reject(new Error(`Stack '${stackId}' not found (404)`));
+        } else if (useHttps && (res.statusCode === 500 || res.statusCode >= 400)) {
+          if (canFallbackToHttp(baseUrl)) {
+            console.log(`HTTPS failed (${res.statusCode}), trying HTTP...`);
+            downloadStackWithHttp(baseUrl, stackId)
+              .then(resolve)
+              .catch(reject);
+          } else {
+            reject(new Error(`HTTPS failed (${res.statusCode}) and HTTP fallback is disabled`));
+          }
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+        }
+      })
+      .on('error', (err) => {
+        if (useHttps) {
+          if (canFallbackToHttp(baseUrl)) {
+            console.log(`HTTPS failed (${err.message}), trying HTTP...`);
+            downloadStackWithHttp(baseUrl, stackId)
+              .then(resolve)
+              .catch(reject);
+          } else {
+            reject(err);
+          }
+        } else {
+          reject(err);
+        }
+      });
+  });
+}
+
+function downloadStackWithHttp(baseUrl, stackId) {
+  return new Promise((resolve, reject) => {
+    const url = `http://${baseUrl}${STACK_API_PREFIX}${stackId}${STACK_API_SUFFIX}`;
+
+    console.log(`Trying HTTP: ${url}`);
+
+    http
+      .get(url, (res) => {
+        if (res.statusCode === 200) {
+          let data = '';
+          res.on('data', (chunk) => {
+            data += chunk;
+          });
+          res.on('end', () => {
+            try {
+              const parsed = JSON.parse(data);
+              resolve(parsed);
+            } catch (parseError) {
+              reject(new Error('Received invalid JSON while downloading stack'));
+            }
+          });
+        } else if (res.statusCode === 404) {
+          reject(new Error(`Stack '${stackId}' not found (404)`));
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+        }
+      })
+      .on('error', reject);
+  });
+}
+
+function findClosestFolder(folderName) {
+  let currentDir = process.cwd();
+
+  while (true) {
+    const candidate = path.join(currentDir, folderName);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+
+  return null;
+}
+
+function resolveClaudeDirectory(subFolder) {
+  const projectClaudeDir = findClosestFolder('.claude');
+  if (projectClaudeDir) {
+    return path.join(projectClaudeDir, subFolder);
+  }
+  return path.join(os.homedir(), '.claude', subFolder);
+}
+
+function resolveCursorDirectory(subFolder) {
+  const projectCursorDir = findClosestFolder('.cursor');
+  if (!projectCursorDir) {
+    const message =
+      'Unable to find a .cursor directory. Run this command from inside a Cursor project.';
+    throw new Error(message);
+  }
+  return path.join(projectCursorDir, subFolder);
+}
+
+function ensureDirectoryExists(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+    console.log(`Created directory: ${dirPath}`);
+  }
+}
+
+function checkFileExists(commandsDir, filename) {
+  const filePath = path.join(commandsDir, filename);
+  return fs.existsSync(filePath);
+}
+
+function saveCommand({
+  directory,
+  filename,
+  content,
+  fullPath,
+  target,
+}) {
+  const filePath = path.join(directory, filename);
+  const relativeDir = path.relative(process.cwd(), directory);
+  const displayPath = relativeDir
+    ? path.join(relativeDir, filename)
+    : filename;
+
+  console.log(`📁 Saving command to ${displayPath}`);
+
+  fs.writeFileSync(filePath, content, 'utf8');
+
+  const commandName = filename.replace(path.extname(filename), '');
+  logSuccessMessage(target, fullPath, commandName);
+}
+
+function logSuccessMessage(target, fullPath, commandName) {
+  switch (target) {
+    case INSTALLATION_TARGETS.CLAUDE_SLASH:
+      console.log(`✅ Command '${fullPath}' installed successfully`);
+      console.log(`\n🎉 You can now use: /${commandName}`);
+      break;
+    case INSTALLATION_TARGETS.CLAUDE_SUB_AGENT:
+      console.log(`✅ Agent '${fullPath}' installed successfully`);
+      console.log(
+        `\n🎉 You can now select '${commandName}' from Claude Desktop's agent menu.`
+      );
+      break;
+    case INSTALLATION_TARGETS.CURSOR_COMMAND:
+      console.log(`✅ Cursor command '${fullPath}' installed successfully`);
+      console.log(
+        `\n🎉 Open Cursor and run '${commandName}' from the command palette.`
+      );
+      break;
+    case INSTALLATION_TARGETS.CURSOR_RULE:
+      console.log(`✅ Cursor rule '${fullPath}' installed successfully`);
+      console.log(
+        `\n🎉 Cursor will apply '${commandName}' to this project.`
+      );
+      break;
+    default:
+      console.log(`✅ '${fullPath}' installed successfully`);
+  }
+}
+
+function parseCommandArgs(args) {
+  let mode = MODES.COMMAND;
+  let identifier = null;
+  let target = null;
+  let showHelpFlag = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+
+    if (arg === '--help' || arg === '-h') {
+      showHelpFlag = true;
+      continue;
+    }
+
+    if (arg.startsWith('--target')) {
+      let rawValue = null;
+      if (arg.includes('=')) {
+        rawValue = arg.split('=')[1];
+      } else {
+        rawValue = args[i + 1];
+        i += 1;
+      }
+
+      if (!rawValue) {
+        throw new Error('Missing value for --target option');
+      }
+
+      const normalizedTarget = rawValue.toLowerCase();
+      if (!KNOWN_TARGETS.includes(normalizedTarget)) {
+        throw new Error(
+          `Unknown target '${rawValue}'. Available targets: ${KNOWN_TARGETS.join(', ')}`
+        );
+      }
+
+      target = normalizedTarget;
+      continue;
+    }
+
+    if (arg === '-t') {
+      const rawValue = args[i + 1];
+      i += 1;
+
+      if (!rawValue) {
+        throw new Error('Missing value for -t option');
+      }
+
+      const normalizedTarget = rawValue.toLowerCase();
+      if (!KNOWN_TARGETS.includes(normalizedTarget)) {
+        throw new Error(
+          `Unknown target '${rawValue}'. Available targets: ${KNOWN_TARGETS.join(', ')}`
+        );
+      }
+
+      target = normalizedTarget;
+      continue;
+    }
+
+    if (mode === MODES.COMMAND && arg === 'stack' && !identifier) {
+      mode = MODES.STACK;
+      continue;
+    }
+
+    if (!identifier) {
+      identifier = arg;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return { mode, identifier, target, showHelp: showHelpFlag };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  try {
+    const {
+      mode,
+      identifier,
+      target,
+      showHelp: helpRequested,
+    } = parseCommandArgs(args);
+
+    if (helpRequested || args.length === 0) {
+      showHelp();
+      return;
+    }
+
+    const baseUrl = normalizeBaseHost(process.env.IMPULSE_BASE_URL || DEFAULT_BASE_URL);
+
+    if (mode === MODES.COMMAND) {
+      if (!identifier) {
+        console.error('❌ Error: Missing command path');
+        showHelp();
+        process.exit(1);
+      }
+
+      if (!identifier.includes('/')) {
+        console.error('❌ Error: Path must include user/command format');
+        showHelp();
+        process.exit(1);
+      }
+
+      const resolvedTarget = target || DEFAULT_TARGET;
+      const targetConfig = TARGET_CONFIG[resolvedTarget];
+
+      if (!targetConfig) {
+        console.error(`❌ Error: Unsupported target '${resolvedTarget}'`);
+        process.exit(1);
+      }
+
+      const directory = targetConfig.resolveDirectory();
+
+      ensureDirectoryExists(directory);
+
+      const commandName = identifier.split('/').pop();
+      const simpleFilename = `${commandName}${targetConfig.extension}`;
+      const fallbackFilename = `${identifier.replace('/', '-')}${targetConfig.extension}`;
+      const fileExists = checkFileExists(directory, simpleFilename);
+      const filename = fileExists ? fallbackFilename : simpleFilename;
+
+      const content = await downloadCommand(baseUrl, identifier);
+
+      saveCommand({
+        directory,
+        filename,
+        content,
+        fullPath: identifier,
+        target: resolvedTarget,
+      });
+      return;
+    }
+
+    if (!identifier) {
+      console.error('❌ Error: Missing stack identifier');
+      showHelp();
+      process.exit(1);
+    }
+
+    const stackPayload = await downloadStack(baseUrl, identifier);
+    const stack = stackPayload.stack || {};
+    const prompts = Array.isArray(stackPayload.prompts)
+      ? stackPayload.prompts
+      : [];
+
+    console.log(
+      `📦 Installing stack '${stack.title || identifier}' (${prompts.length} prompt${
+        prompts.length === 1 ? '' : 's'
+      })`
+    );
+
+    let installed = 0;
+    let skipped = 0;
+
+    for (let index = 0; index < prompts.length; index += 1) {
+      const prompt = prompts[index];
+      const commandPath = prompt.path || prompt.slug || prompt.id || `prompt-${index + 1}`;
+      const baseName = prompt.slug || `prompt-${index + 1}`;
+
+      const resolvedTarget = target || prompt.target || DEFAULT_TARGET;
+      const targetConfig = TARGET_CONFIG[resolvedTarget];
+      if (!targetConfig) {
+        console.warn(`⚠️  Skipping prompt '${commandPath}' (unsupported target '${resolvedTarget}')`);
+        skipped += 1;
+        continue;
+      }
+
+      const directory = targetConfig.resolveDirectory();
+      ensureDirectoryExists(directory);
+
+      const simpleFilename = `${baseName}${targetConfig.extension}`;
+      const fallbackBase = stack.slug
+        ? `${stack.slug}-${baseName}`
+        : `${stack.id || identifier}-${baseName}`;
+      const fallbackFilename = `${fallbackBase}${targetConfig.extension}`;
+
+      const simpleExists = checkFileExists(directory, simpleFilename);
+      const fallbackExists = checkFileExists(directory, fallbackFilename);
+
+      let filename = simpleFilename;
+      if (simpleExists) {
+        filename = fallbackFilename;
+      }
+      if ((simpleExists && fallbackExists) || checkFileExists(directory, filename)) {
+        const baseForUniq = fallbackBase;
+        const ext = targetConfig.extension;
+        let counter = 1;
+        let candidate = `${baseForUniq}-${counter}${ext}`;
+        while (checkFileExists(directory, candidate)) {
+          counter += 1;
+          candidate = `${baseForUniq}-${counter}${ext}`;
+        }
+        filename = candidate;
+      }
+
+      if (!prompt.markdown) {
+        console.warn(`⚠️  Skipping prompt '${commandPath}' (no content available)`);
+        skipped += 1;
+        continue;
+      }
+
+      saveCommand({
+        directory,
+        filename,
+        content: prompt.markdown,
+        fullPath: commandPath,
+        target: resolvedTarget,
+      });
+      installed += 1;
+    }
+
+    console.log(
+      `🎉 Installed ${installed} prompt${installed === 1 ? '' : 's'} from stack '${
+        stack.title || identifier
+      }'${skipped ? ` (skipped ${skipped})` : ''}`
+    );
+  } catch (error) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@impulselab/directory",
+  "version": "1.0.0",
+  "description": "Download and install Claude commands from Impulse Directory",
+  "main": "index.js",
+  "bin": {
+    "impulse-directory": "./index.js"
+  },
+  "keywords": [
+    "claude",
+    "commands",
+    "impulse",
+    "npx"
+  ],
+  "author": "Impulse",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node index.js --help",
+    "predeploy": "chmod +x index.js",
+    "deploy": "pnpm publish --access public --no-git-checks"
+  }
+}