@orderful/droid 0.2.0

package/dist/lib/types.js

@@ -0,0 +1,31 @@
+export var AITool;
+(function (AITool) {
+    AITool["ClaudeCode"] = "claude-code";
+    AITool["OpenCode"] = "opencode";
+})(AITool || (AITool = {}));
+/**
+ * Get the AI's mention tag
+ * Always @droid - consistent branding regardless of underlying AI tool
+ */
+export function getAITag() {
+    return '@droid';
+}
+// Built-in output preferences (always available)
+export var BuiltInOutput;
+(function (BuiltInOutput) {
+    BuiltInOutput["Terminal"] = "terminal";
+    BuiltInOutput["Editor"] = "editor";
+})(BuiltInOutput || (BuiltInOutput = {}));
+export var SkillStatus;
+(function (SkillStatus) {
+    SkillStatus["Stable"] = "stable";
+    SkillStatus["Beta"] = "beta";
+    SkillStatus["Alpha"] = "alpha";
+})(SkillStatus || (SkillStatus = {}));
+export var ConfigOptionType;
+(function (ConfigOptionType) {
+    ConfigOptionType["String"] = "string";
+    ConfigOptionType["Boolean"] = "boolean";
+    ConfigOptionType["Select"] = "select";
+})(ConfigOptionType || (ConfigOptionType = {}));
+//# sourceMappingURL=types.js.map

package/dist/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,MAGX;AAHD,WAAY,MAAM;IAChB,oCAA0B,CAAA;IAC1B,+BAAqB,CAAA;AACvB,CAAC,EAHW,MAAM,KAAN,MAAM,QAGjB;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ;IACtB,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,iDAAiD;AACjD,MAAM,CAAN,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,sCAAqB,CAAA;IACrB,kCAAiB,CAAA;AACnB,CAAC,EAHW,aAAa,KAAb,aAAa,QAGxB;AAKD,MAAM,CAAN,IAAY,WAIX;AAJD,WAAY,WAAW;IACrB,gCAAiB,CAAA;IACjB,4BAAa,CAAA;IACb,8BAAe,CAAA;AACjB,CAAC,EAJW,WAAW,KAAX,WAAW,QAItB;AAED,MAAM,CAAN,IAAY,gBAIX;AAJD,WAAY,gBAAgB;IAC1B,qCAAiB,CAAA;IACjB,uCAAmB,CAAA;IACnB,qCAAiB,CAAA;AACnB,CAAC,EAJW,gBAAgB,KAAhB,gBAAgB,QAI3B"}

package/dist/lib/version.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get the current version from package.json
+ */
+export declare function getVersion(): string;
+/**
+ * Check for updates (non-blocking)
+ * Shows a message if a new version is available
+ */
+export declare function checkForUpdates(): Promise<void>;
+//# sourceMappingURL=version.d.ts.map

package/dist/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/lib/version.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAOnC;AAED;;;GAGG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAqBrD"}

package/dist/lib/version.js

@@ -0,0 +1,41 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = join(__dirname, '../../package.json');
+/**
+ * Get the current version from package.json
+ */
+export function getVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * Check for updates (non-blocking)
+ * Shows a message if a new version is available
+ */
+export async function checkForUpdates() {
+    try {
+        const currentVersion = getVersion();
+        // Use npm view to check latest version
+        const latestVersion = execSync('npm view @orderful/droid version 2>/dev/null', {
+            encoding: 'utf-8',
+            timeout: 3000,
+        }).trim();
+        if (latestVersion && latestVersion !== currentVersion) {
+            console.log(chalk.yellow(`\n⚠️  A new version of droid is available (${currentVersion} → ${latestVersion})`));
+            console.log(chalk.yellow(`   Run ${chalk.bold('droid update')} to upgrade\n`));
+        }
+    }
+    catch {
+        // Silently fail - update check is non-critical
+    }
+}
+//# sourceMappingURL=version.js.map

package/dist/lib/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/lib/version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC1D,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAC;AAE9D;;GAEG;AACH,MAAM,UAAU,UAAU;IACxB,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC,CAAC;QAC/D,OAAO,GAAG,CAAC,OAAiB,CAAC;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,OAAO,CAAC;IACjB,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACnC,IAAI,CAAC;QACH,MAAM,cAAc,GAAG,UAAU,EAAE,CAAC;QAEpC,uCAAuC;QACvC,MAAM,aAAa,GAAG,QAAQ,CAAC,8CAA8C,EAAE;YAC7E,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,IAAI;SACd,CAAC,CAAC,IAAI,EAAE,CAAC;QAEV,IAAI,aAAa,IAAI,aAAa,KAAK,cAAc,EAAE,CAAC;YACtD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,MAAM,CACV,8CAA8C,cAAc,MAAM,aAAa,GAAG,CACnF,CACF,CAAC;YACF,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,UAAU,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,+CAA+C;IACjD,CAAC;AACH,CAAC"}

package/dist/skills/comments/SKILL.md

@@ -0,0 +1,65 @@
+# Comments Skill
+
+Enable inline conversation in any file using `> @droid` and `> @{user}` markers.
+
+## How It Works
+
+Leave comments for the AI using `> @droid`:
+
+```markdown
+> @droid What do you think of this approach?
+
+> @droid Can you add error handling here?
+```
+
+The AI will respond with `> @{user_mention}` (configured in droid setup, e.g., `@fry`):
+
+```markdown
+> @fry I think this approach is solid. One consideration...
+```
+
+## Tag Convention
+
+| Who | Tag |
+|-----|-----|
+| AI | `@droid` (+ any configured aliases) |
+| User | Configured (e.g., `@fry`) |
+
+## Commands
+
+- `/comments check` - Scan for AI markers and address each one
+- `/comments check {path}` - Scope to specific file or directory
+- `/comments cleanup` - Find resolved comment threads and remove them
+
+## Behavior
+
+### On `/comments check`:
+1. Search for `> @droid` (and any configured `ai_mentions`) in the specified scope
+2. If there's a `git diff`, check those files first for relevant context
+3. For each comment, determine intent:
+   - **Action request** ("do X", "add Y", "fix Z") → Execute the action, remove the comment
+   - **Question** ("what do you think", "should we") → Respond with `> @{user_mention}`, keep original comment
+
+### On `/comments cleanup`:
+1. Find AI tag and `> @{user_mention}` pairs where conversation appears resolved
+2. Remove both markers
+3. Output a summary of what was discussed/decided
+
+## Configuration
+
+Configured via `~/.droid/skills/comments/overrides.yaml` or inherits from global `~/.droid/config.yaml`:
+
+```yaml
+# Override the user mention (default: from global config)
+user_mention: "@fry"
+
+# Additional AI mentions to recognize (e.g., if you're used to @claude)
+ai_mentions: "@claude"
+
+# Keep comments after addressing them (default: false)
+preserve_comments: false
+```
+
+## File Type Support
+
+Works in any text file. Respects `.gitignore` and skips common build directories (node_modules, dist, .git, etc.).

package/dist/skills/comments/SKILL.yaml

@@ -0,0 +1,18 @@
+name: comments
+description: Inline conversation in any file via @droid/@user markers
+version: 0.1.0
+status: beta
+dependencies: []
+provides_output: false
+config_schema:
+  user_mention:
+    type: string
+    description: Override the global user mention for this skill
+  ai_mentions:
+    type: string
+    description: Additional AI mentions to recognize (comma-separated, e.g., "@claude,@ai")
+    default: ""
+  preserve_comments:
+    type: boolean
+    description: Keep original comments after addressing (vs removing them)
+    default: false

package/dist/skills/comments/commands/comments.md

@@ -0,0 +1,48 @@
+# /comments - Check and respond to inline comments
+
+Check for `> @droid` comments (and configured aliases like `@claude`) in files and address them.
+
+## Usage
+
+```
+/comments              # Check all files in cwd
+/comments check        # Same as above
+/comments check {path} # Check specific file or directory
+/comments cleanup      # Remove resolved comment threads
+```
+
+## Arguments
+
+$ACTION - The action to perform: check (default) or cleanup
+$PATH - Optional path to scope the search
+
+## Behavior
+
+When you find a `> @droid` comment (or configured alias):
+
+1. **Read the context** - Understand what the comment is asking by reading surrounding code/text
+2. **Determine intent**:
+   - If it's an **action request** (e.g., "add error handling", "refactor this"):
+     - Execute the requested action
+     - Remove the comment (unless preserve_comments is true)
+   - If it's a **question** (e.g., "what do you think?", "is this approach good?"):
+     - Respond with `> @{user_mention}` on a new line below
+     - Keep the original comment for context
+3. **Check git diff first** - If there's uncommitted changes, prioritize checking those files
+
+## Response Format
+
+When responding to questions, use the configured user tag:
+
+```markdown
+> @droid Should we use async/await here?
+
+> @fry Yes, async/await would be cleaner here because...
+```
+
+## Configuration
+
+Check `~/.droid/skills/comments/overrides.yaml` for:
+- `user_mention` - Your @mention for responses
+- `ai_mentions` - Additional mentions to recognize (e.g., `@claude`)
+- `preserve_comments` - Keep or remove addressed comments

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@orderful/droid",
+  "version": "0.2.0",
+  "description": "AI workflow toolkit for sharing skills, commands, and agents across the team",
+  "type": "module",
+  "bin": {
+    "droid": "./dist/bin/droid.js"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && cp -r src/skills dist/",
+    "dev": "tsc --watch",
+    "start": "bun dist/bin/droid.js",
+    "test": "bun test src/",
+    "test:watch": "bun test src/ --watch",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write 'src/**/*.ts'",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "bun run build && changeset publish",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "ai",
+    "claude",
+    "cli",
+    "developer-tools",
+    "workflow"
+  ],
+  "author": "Orderful Engineering",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orderful/droid.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "inquirer": "^9.2.15",
+    "ora": "^8.0.1",
+    "yaml": "^2.4.1"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@types/bun": "latest",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.11.24",
+    "@typescript-eslint/eslint-plugin": "^8.49.0",
+    "@typescript-eslint/parser": "^8.49.0",
+    "eslint": "^8.57.0",
+    "prettier": "^3.2.5",
+    "typescript": "^5.4.2"
+  }
+}

package/src/bin/droid.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { setupCommand } from '../commands/setup.js';
+import { configCommand } from '../commands/config.js';
+import { skillsCommand } from '../commands/skills.js';
+import { installCommand } from '../commands/install.js';
+import { uninstallCommand } from '../commands/uninstall.js';
+import { updateCommand } from '../commands/update.js';
+import { getVersion, checkForUpdates } from '../lib/version.js';
+
+const version = getVersion();
+
+program
+  .name('droid')
+  .description('AI workflow toolkit - teaching your droid new tricks')
+  .version(version);
+
+program
+  .command('setup')
+  .description('Interactive wizard for global configuration')
+  .action(setupCommand);
+
+program
+  .command('config')
+  .description('View or edit configuration')
+  .option('-e, --edit', 'Open config in editor')
+  .option('-g, --get <key>', 'Get a specific config value')
+  .option('-s, --set <key=value>', 'Set a config value')
+  .action(configCommand);
+
+program
+  .command('skills')
+  .description('Browse and manage available skills')
+  .action(skillsCommand);
+
+program
+  .command('install <skill>')
+  .description('Install a skill and run its setup wizard')
+  .action(installCommand);
+
+program
+  .command('uninstall <skill>')
+  .description('Uninstall a skill')
+  .action(uninstallCommand);
+
+program
+  .command('update')
+  .description('Update droid and installed skills')
+  .option('--skills', 'Only update skills')
+  .option('--cli', 'Only update the CLI')
+  .argument('[skill]', 'Update a specific skill')
+  .action(updateCommand);
+
+// Check for updates on any command (non-blocking)
+checkForUpdates().catch(() => {});
+
+program.parse();

package/src/commands/config.ts

@@ -0,0 +1,86 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import {
+  loadConfig,
+  getConfigPath,
+  getConfigValue,
+  setConfigValue,
+  configExists,
+} from '../lib/config.js';
+
+interface ConfigOptions {
+  edit?: boolean;
+  get?: string;
+  set?: string;
+}
+
+export async function configCommand(options: ConfigOptions): Promise<void> {
+  // Handle --edit flag
+  if (options.edit) {
+    const configPath = getConfigPath();
+    const editor = process.env.EDITOR || 'vim';
+
+    if (!configExists()) {
+      console.log(chalk.yellow('No config file exists yet. Run `droid setup` first.'));
+      return;
+    }
+
+    console.log(chalk.gray(`Opening ${configPath} in ${editor}...`));
+    try {
+      execSync(`${editor} "${configPath}"`, { stdio: 'inherit' });
+    } catch {
+      console.error(chalk.red('Failed to open editor'));
+    }
+    return;
+  }
+
+  // Handle --get flag
+  if (options.get) {
+    const value = getConfigValue(options.get);
+    if (value === undefined) {
+      console.log(chalk.yellow(`Config key '${options.get}' not found`));
+      process.exit(1);
+    }
+
+    if (typeof value === 'object') {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      console.log(value);
+    }
+    return;
+  }
+
+  // Handle --set flag
+  if (options.set) {
+    const match = options.set.match(/^([^=]+)=(.*)$/);
+    if (!match) {
+      console.error(chalk.red('Invalid format. Use: --set key=value'));
+      process.exit(1);
+    }
+
+    const [, key, rawValue] = match;
+
+    // Try to parse as JSON, otherwise use as string
+    let value: unknown;
+    try {
+      value = JSON.parse(rawValue);
+    } catch {
+      value = rawValue;
+    }
+
+    setConfigValue(key, value);
+    console.log(chalk.green(`✓ Set ${key} = ${JSON.stringify(value)}`));
+    return;
+  }
+
+  // Default: show full config
+  if (!configExists()) {
+    console.log(chalk.yellow('No config file exists yet. Run `droid setup` first.'));
+    return;
+  }
+
+  const config = loadConfig();
+  console.log(chalk.bold('\n📋 Droid Config\n'));
+  console.log(chalk.gray(`Path: ${getConfigPath()}\n`));
+  console.log(JSON.stringify(config, null, 2));
+}

package/src/commands/install.ts

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { join } from 'path';
+import { installSkill, isSkillInstalled, getBundledSkills, loadSkillManifest, getBundledSkillsDir } from '../lib/skills.js';
+import { promptForSkillConfig } from '../lib/skill-config.js';
+
+export async function installCommand(skillName: string): Promise<void> {
+  // Check if skill exists
+  const skills = getBundledSkills();
+  const skill = skills.find((s) => s.name === skillName);
+
+  if (!skill) {
+    console.error(chalk.red(`\n✗ Skill '${skillName}' not found`));
+    console.log(chalk.gray('\nAvailable skills:'));
+    for (const s of skills) {
+      console.log(chalk.gray(`  - ${s.name}`));
+    }
+    process.exit(1);
+  }
+
+  // Check if already installed
+  if (isSkillInstalled(skillName)) {
+    console.log(chalk.yellow(`\n⚠ Skill '${skillName}' is already installed`));
+    console.log(chalk.gray('Use `droid update` to update it, or uninstall first.'));
+    return;
+  }
+
+  console.log(chalk.bold(`\n🤖 Installing ${skillName}...\n`));
+
+  const result = installSkill(skillName);
+
+  if (result.success) {
+    console.log(chalk.green(`✓ ${result.message}`));
+
+    // Check if skill has configurable options
+    const manifest = loadSkillManifest(join(getBundledSkillsDir(), skillName));
+    if (manifest?.config_schema && Object.keys(manifest.config_schema).length > 0) {
+      await promptForSkillConfig(skillName, manifest.config_schema, true);
+    }
+
+    // Show next steps
+    console.log(chalk.gray('\nNext steps:'));
+    console.log(chalk.gray('  - Run your AI tool to start using the skill'));
+    console.log(chalk.gray(`  - Reconfigure anytime with \`droid skills\` → Configure`));
+  } else {
+    console.error(chalk.red(`✗ ${result.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/setup.ts

@@ -0,0 +1,149 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { loadConfig, saveConfig, configExists } from '../lib/config.js';
+import { getBundledSkills } from '../lib/skills.js';
+import { AITool, BuiltInOutput, type DroidConfig, type OutputPreference } from '../lib/types.js';
+
+/**
+ * Detect which AI tool is installed
+ */
+function detectAITool(): AITool | null {
+  try {
+    execSync('claude --version', { stdio: 'ignore' });
+    return AITool.ClaudeCode;
+  } catch {
+    // Claude Code not found
+  }
+
+  try {
+    execSync('opencode --version', { stdio: 'ignore' });
+    return AITool.OpenCode;
+  } catch {
+    // OpenCode not found
+  }
+
+  return null;
+}
+
+/**
+ * Try to get git username
+ */
+function detectGitUsername(): string {
+  try {
+    return execSync('git config user.name', { encoding: 'utf-8' }).trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Get available output options (built-in + skills that provide output)
+ */
+function getOutputOptions(): Array<{ name: string; value: OutputPreference }> {
+  const options: Array<{ name: string; value: OutputPreference }> = [
+    { name: 'Terminal (display in CLI)', value: BuiltInOutput.Terminal },
+    { name: 'Editor ($EDITOR)', value: BuiltInOutput.Editor },
+  ];
+
+  // Add skills that provide output targets
+  const skills = getBundledSkills();
+  for (const skill of skills) {
+    if (skill.provides_output) {
+      options.push({
+        name: `${skill.name} (${skill.description})`,
+        value: skill.name,
+      });
+    }
+  }
+
+  return options;
+}
+
+export async function setupCommand(): Promise<void> {
+  console.log(chalk.bold('\n🤖 Droid Setup\n'));
+
+  const existingConfig = configExists();
+  if (existingConfig) {
+    const { overwrite } = await inquirer.prompt<{ overwrite: boolean }>([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: 'Config already exists. Overwrite?',
+        default: false,
+      },
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.gray('Setup cancelled.'));
+      return;
+    }
+  }
+
+  // Detect AI tool
+  const detectedTool = detectAITool();
+  if (detectedTool) {
+    console.log(chalk.green(`✓ Detected ${detectedTool}\n`));
+  } else {
+    console.log(chalk.yellow('⚠ No AI tool detected (Claude Code or OpenCode)\n'));
+  }
+
+  // Detect git username
+  const detectedGitUsername = detectGitUsername();
+
+  // Get dynamic output options
+  const outputOptions = getOutputOptions();
+
+  const answers = await inquirer.prompt<{
+    ai_tool: AITool;
+    user_mention: string;
+    output_preference: OutputPreference;
+    git_username: string;
+  }>([
+    {
+      type: 'list',
+      name: 'ai_tool',
+      message: 'Which AI tool are you using?',
+      choices: [
+        { name: 'Claude Code', value: AITool.ClaudeCode },
+        { name: 'OpenCode', value: AITool.OpenCode },
+      ],
+      default: detectedTool || AITool.ClaudeCode,
+    },
+    {
+      type: 'input',
+      name: 'user_mention',
+      message: 'What @mention should be used for you?',
+      default: '@user',
+      validate: (input: string) => {
+        if (!input.startsWith('@')) {
+          return 'Mention should start with @';
+        }
+        return true;
+      },
+    },
+    {
+      type: 'list',
+      name: 'output_preference',
+      message: 'Default output preference for skill results?',
+      choices: outputOptions,
+      default: BuiltInOutput.Terminal,
+    },
+    {
+      type: 'input',
+      name: 'git_username',
+      message: 'Git username for attribution?',
+      default: detectedGitUsername || '',
+    },
+  ]);
+
+  const config: DroidConfig = {
+    ...loadConfig(),
+    ...answers,
+  };
+
+  saveConfig(config);
+
+  console.log(chalk.green('\n✓ Config saved to ~/.droid/config.yaml'));
+  console.log(chalk.gray('\nRun `droid skills` to browse and install skills.'));
+}