@dk/jolly 0.1.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@dk/jolly",
+  "version": "0.1.0",
+  "description": "Saleor project bootstrapper and agent configurator",
+  "type": "module",
+  "bin": {
+    "jolly": "./dist/index.js",
+    "create-saleor-jolly": "./dist/bootstrap.js",
+    "init-saleor-jolly": "./dist/agent.js"
+  },
+  "scripts": {
+    "build": "bun build src/cli/index.ts --outdir=dist --target=bun && bun build src/cli/bootstrap.ts --outdir=dist --target=bun && bun build src/cli/agent.ts --outdir=dist --target=bun",
+    "dev": "bun --watch src/cli/index.ts",
+    "test": "bun test",
+    "typecheck": "bun tsc --noEmit"
+  },
+  "dependencies": {
+    "dotenv": "^17.4.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/yargs": "^17.0.32",
+    "bun-types": "^1.3.11",
+    "typescript": "^5.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/agents/index.ts

@@ -0,0 +1 @@
+export {};

package/src/agents/setup.ts

@@ -0,0 +1,210 @@
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { spawnSync } from 'child_process';
+import { join } from 'path';
+import { success, error, info } from '../tui/components.js';
+
+interface DetectedAgent {
+  name: string;
+  path: string;
+  skillsPath: string;
+}
+
+const AGENT_PATHS = {
+  opencode: {
+    skills: '.agents/skills',
+    agentsMd: 'AGENTS.md',
+    mcpJson: '.mcp.json',
+  },
+  claude: {
+    skills: '.claude/skills',
+    agentsMd: 'CLAUDE.md',
+    mcpJson: '.mcp.json',
+  },
+  openclaw: {
+    skills: '.openclaw/skills',
+    agentsMd: 'AGENTS.md',
+    mcpJson: '.mcp.json',
+  },
+  nanobot: {
+    skills: '.nanobot/skills',
+    agentsMd: 'AGENTS.md',
+    mcpJson: '.mcp.json',
+  },
+};
+
+const SKILLS = [
+  'saleor-app',
+  'saleor-configurator',
+  'saleor-core',
+  'saleor-storefront',
+];
+
+export async function setupAgent(projectPath: string = '.'): Promise<void> {
+  info('Detecting AI agents...');
+
+  const detectedAgents = detectAgents(projectPath);
+
+  if (detectedAgents.length === 0) {
+    info('No AI agents detected. Installing skills anyway...');
+    installSkills(projectPath, 'opencode');
+    createAgentsMd(projectPath);
+    createMcpConfig(projectPath);
+    return;
+  }
+
+  info(`Detected agents: ${detectedAgents.map(a => a.name).join(', ')}\n`);
+
+  for (const agent of detectedAgents) {
+    info(`Configuring ${agent.name}...`);
+    installSkills(projectPath, agent.name as keyof typeof AGENT_PATHS);
+    createAgentsMd(projectPath, agent.name as keyof typeof AGENT_PATHS);
+    createMcpConfig(projectPath);
+    success(`  ${agent.name} configured!`);
+  }
+
+  success('\nAgent setup complete!');
+  info('\nSkills installed: ' + SKILLS.join(', '));
+  info('AGENTS.md created with Saleor conventions');
+  info('.mcp.json configured for saleor-mcp');
+}
+
+export async function installSkillsCommand(projectPath: string = '.'): Promise<void> {
+  info('Installing Saleor agent skills...');
+  info('Skills: ' + SKILLS.join(', '));
+
+  const detectedAgents = detectAgents(projectPath);
+
+  if (detectedAgents.length === 0) {
+    installSkills(projectPath, 'opencode');
+  } else {
+    for (const agent of detectedAgents) {
+      installSkills(projectPath, agent.name as keyof typeof AGENT_PATHS);
+    }
+  }
+
+  success('\nSkills installed successfully!');
+}
+
+function detectAgents(projectPath: string): DetectedAgent[] {
+  const detected: DetectedAgent[] = [];
+
+  const filesToCheck = [
+    { name: 'opencode', file: '.agents/skills' },
+    { name: 'claude', file: '.claude' },
+    { name: 'openclaw', file: '.openclaw' },
+    { name: 'nanobot', file: '.nanobot' },
+  ];
+
+  for (const { name, file } of filesToCheck) {
+    const fullPath = join(projectPath, file);
+    if (existsSync(fullPath)) {
+      detected.push({
+        name,
+        path: fullPath,
+        skillsPath: join(fullPath, 'skills'),
+      });
+    }
+  }
+
+  return detected;
+}
+
+function installSkills(projectPath: string, agentName: keyof typeof AGENT_PATHS): void {
+  const agentPaths = AGENT_PATHS[agentName];
+  const skillsDir = join(projectPath, agentPaths.skills);
+
+  mkdirSync(skillsDir, { recursive: true });
+
+  info(`  Installing skills to ${skillsDir}...`);
+
+  // Skills are installed via git clone from saleor/agent-skills repo
+  // Each skill is a subdirectory in the repo
+  const skillUrl = 'https://github.com/saleor/agent-skills';
+  const baseDir = join(skillsDir, '..');
+
+  try {
+    const result = spawnSync('git', ['clone', '--depth', '1', skillUrl, 'skills'], {
+      cwd: baseDir,
+      stdio: 'pipe',
+    });
+
+    if (result.status === 0) {
+      for (const skill of SKILLS) {
+        info(`  Installed ${skill}`);
+      }
+      success(`  Skills installed to ${skillsDir}`);
+    } else {
+      info(`  Could not clone skills, skipping...`);
+    }
+  } catch {
+    info(`  Could not clone skills, skipping...`);
+  }
+}
+
+function createAgentsMd(projectPath: string, agentName: keyof typeof AGENT_PATHS = 'opencode'): void {
+  const agentsMdContent = `# Saleor Development Guide
+
+This project uses Saleor e-commerce platform.
+
+## Commands
+
+\`\`\`bash
+# Development
+npm run dev
+
+# Build
+npm run build
+
+# Test
+npm run test
+
+# Lint
+npm run lint
+\`\`\`
+
+## Saleor Cloud
+
+- Dashboard: https://cloud.saleor.io
+- Documentation: https://docs.saleor.io
+- API Reference: https://docs.saleor.io/api
+
+## Saleor Skills
+
+This project includes Saleor agent skills:
+- saleor-app: App development patterns
+- saleor-configurator: Config as code
+- saleor-core: Backend internals
+- saleor-storefront: Storefront patterns
+
+## MCP Server
+
+Configure saleor-mcp for AI agent capabilities:
+\`\`\`json
+{
+  "mcpServers": {
+    "saleor": {
+      "url": "https://mcp.saleor.app"
+    }
+  }
+}
+\`\`\`
+`;
+
+  const agentsMdPath = join(projectPath, 'AGENTS.md');
+  writeFileSync(agentsMdPath, agentsMdContent);
+  info(`  Created AGENTS.md`);
+}
+
+function createMcpConfig(projectPath: string): void {
+  const mcpConfig = {
+    mcpServers: {
+      saleor: {
+        url: 'https://mcp.saleor.app',
+      },
+    },
+  };
+
+  const mcpPath = join(projectPath, '.mcp.json');
+  writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2));
+  info(`  Created .mcp.json`);
+}

package/src/api/auth.ts

@@ -0,0 +1,21 @@
+import { config } from 'dotenv';
+
+config();
+
+export function getToken(): string {
+  const token = process.env.SALEOR_CLOUD_TOKEN;
+  if (!token) {
+    throw new Error('SALEOR_CLOUD_TOKEN environment variable is required');
+  }
+  return token;
+}
+
+export function requireToken(): string {
+  const token = process.env.SALEOR_CLOUD_TOKEN;
+  if (!token) {
+    console.error('Error: SALEOR_CLOUD_TOKEN environment variable is required');
+    console.error('Get your token at: https://cloud.saleor.io/settings/api-tokens');
+    process.exit(1);
+  }
+  return token;
+}

package/src/api/client.ts

@@ -0,0 +1,78 @@
+export class SaleorCloudClient {
+  private baseUrl = 'https://cloud.saleor.io/api';
+  private token: string;
+
+  constructor(token?: string) {
+    this.token = token || process.env.SALEOR_CLOUD_TOKEN || '';
+    if (!this.token) {
+      throw new Error('SALEOR_CLOUD_TOKEN environment variable is required');
+    }
+  }
+
+  async request<T>(endpoint: string, options?: RequestInit): Promise<T> {
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        'Authorization': `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+        ...options?.headers,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async getStores() {
+    return this.request<{ stores: Store[] }>('/stores');
+  }
+
+  async createStore(name: string, region: string = 'us-east-1') {
+    return this.request<{ store: Store }>('/stores', {
+      method: 'POST',
+      body: JSON.stringify({ name, region }),
+    });
+  }
+
+  async getEnvironments(storeId: string) {
+    return this.request<{ environments: Environment[] }>(`/stores/${storeId}/environments`);
+  }
+
+  async createEnvironment(storeId: string, name: string) {
+    return this.request<{ environment: Environment }>(`/stores/${storeId}/environments`, {
+      method: 'POST',
+      body: JSON.stringify({ name }),
+    });
+  }
+
+  async registerApp(environmentId: string, appType: string, name: string) {
+    return this.request<{ app: App }>(`/environments/${environmentId}/apps`, {
+      method: 'POST',
+      body: JSON.stringify({ type: appType, name }),
+    });
+  }
+}
+
+export interface Store {
+  id: string;
+  name: string;
+  region: string;
+  created_at: string;
+}
+
+export interface Environment {
+  id: string;
+  name: string;
+  store_id: string;
+  created_at: string;
+}
+
+export interface App {
+  id: string;
+  name: string;
+  type: string;
+  environment_id: string;
+}

package/src/api/endpoints.ts

@@ -0,0 +1,8 @@
+export const endpoints = {
+  stores: '/stores',
+  store: (id: string) => `/stores/${id}`,
+  environments: (storeId: string) => `/stores/${storeId}/environments`,
+  environment: (storeId: string, envId: string) => `/stores/${storeId}/environments/${envId}`,
+  apps: (environmentId: string) => `/environments/${environmentId}/apps`,
+  registerApp: '/apps/register',
+};

package/src/api/index.ts

@@ -0,0 +1,4 @@
+export { SaleorCloudClient } from './client.js';
+export type { Store, Environment, App } from './client.js';
+export { getToken, requireToken } from './auth.js';
+export { endpoints } from './endpoints.js';

package/src/cli/agent.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env bun
+import { setupAgent, installSkillsCommand } from '../agents/setup.js';
+
+async function main() {
+  const args = process.argv.slice(2);
+  const action = args[0] || 'setup';
+
+  if (action === 'setup' || action === 'install') {
+    console.log('Saleor Agent Setup');
+    console.log('-------------------\n');
+    await setupAgent('.');
+    console.log('\nAgent configured successfully!');
+    console.log('Restart your AI agent to enable Saleor capabilities.');
+  } else if (action === 'skills') {
+    await installSkillsCommand('.');
+  } else {
+    console.error(`Unknown action: ${action}`);
+    console.log('Usage: jolly-agent [setup|skills]');
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(`Agent setup failed: ${err}`);
+  process.exit(1);
+});

package/src/cli/bootstrap.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+import { createStore } from '../commands/store.js';
+
+async function main() {
+  const args = process.argv.slice(2);
+  const projectName = args[0];
+
+  if (projectName) {
+    console.log(`Bootstrapping Saleor project: ${projectName}...`);
+    await createStore(projectName, 'us-east-1');
+    return;
+  }
+
+  console.log('Saleor Store Bootstrapper');
+  console.log('------------------------\n');
+  console.log('Usage: npm create @saleor/jolly <project-name>');
+  console.log('Or: jolly store create --name <name>');
+  console.log('\nFor app scaffolding: jolly app create --name <name> --type <type>');
+}
+
+main().catch((err) => {
+  console.error(`Bootstrap failed: ${err}`);
+  process.exit(1);
+});

package/src/cli/commands/agent.ts

@@ -0,0 +1,40 @@
+import type { CommandModule } from 'yargs';
+import { setupAgent, installSkillsCommand } from '../../agents/setup.js';
+
+export const agentCommands: CommandModule = {
+  command: 'agent <action>',
+  describe: 'Configure AI agents for Saleor',
+  builder: (yargs) =>
+    yargs
+      .command({
+        command: 'setup',
+        describe: 'Setup AI agent with Saleor skills and MCP',
+        builder: (yargs) => yargs.option('path', {
+          alias: 'p',
+          type: 'string',
+          description: 'Project path',
+          default: '.',
+        }),
+        handler: async (argv) => {
+          await setupAgent(argv.path as string);
+        },
+      })
+      .command({
+        command: 'skills',
+        describe: 'Install Saleor agent skills',
+        builder: (yargs) =>
+          yargs.command({
+            command: 'install',
+            describe: 'Install Saleor skills',
+            builder: (yargs) => yargs.option('path', {
+              alias: 'p',
+              type: 'string',
+              description: 'Project path',
+              default: '.',
+            }),
+            handler: async (argv) => {
+              await installSkillsCommand(argv.path as string);
+            },
+          }),
+      }),
+};

package/src/cli/commands/app.ts

@@ -0,0 +1,51 @@
+import type { CommandModule } from 'yargs';
+import { createApp } from '../../commands/app.js';
+
+type AppType = 'dashboard-extension' | 'payment' | 'webhook';
+type PaymentProvider = 'dummy' | 'stripe';
+
+export const appCommands: CommandModule = {
+  command: 'app <action>',
+  describe: 'Scaffold Saleor apps',
+  builder: (yargs) =>
+    yargs
+      .command({
+        command: 'create',
+        describe: 'Create a new Saleor app',
+        builder: (yargs) =>
+          yargs
+            .option('name', {
+              alias: 'n',
+              type: 'string',
+              description: 'App name',
+              demandOption: true,
+            })
+            .option('type', {
+              alias: 't',
+              type: 'string',
+              choices: ['dashboard-extension', 'payment', 'webhook'],
+              description: 'App type',
+              demandOption: true,
+            })
+            .option('provider', {
+              alias: 'p',
+              type: 'string',
+              choices: ['dummy', 'stripe'],
+              description: 'Payment provider (for payment apps)',
+              default: 'dummy',
+            })
+            .option('environment', {
+              alias: 'e',
+              type: 'string',
+              description: 'Environment ID to register app with',
+            }),
+        handler: async (argv) => {
+          await createApp(
+            argv.name,
+            argv.type as AppType,
+            argv.environment,
+            argv.provider as PaymentProvider
+          );
+        },
+      }),
+};

package/src/cli/commands/config.ts

@@ -0,0 +1,38 @@
+import type { CommandModule } from 'yargs';
+
+export const configCommands: CommandModule = {
+  command: 'config <action>',
+  describe: 'Manage Saleor configuration',
+  builder: (yargs) =>
+    yargs
+      .command({
+        command: 'deploy',
+        describe: 'Deploy configuration to a store',
+        builder: (yargs) =>
+          yargs.option('store', {
+            alias: 's',
+            type: 'string',
+            description: 'Store ID',
+            demandOption: true,
+          }),
+        handler: async (argv) => {
+          console.log(`Deploying config to store: ${argv.store}`);
+          console.log('Config deployment not yet implemented');
+        },
+      })
+      .command({
+        command: 'introspect',
+        describe: 'Introspect current store configuration',
+        builder: (yargs) =>
+          yargs.option('store', {
+            alias: 's',
+            type: 'string',
+            description: 'Store ID',
+            demandOption: true,
+          }),
+        handler: async (argv) => {
+          console.log(`Introspecting store: ${argv.store}`);
+          console.log('Config introspection not yet implemented');
+        },
+      }),
+};

package/src/cli/commands/store.ts

@@ -0,0 +1,65 @@
+import type { CommandModule } from 'yargs';
+import { createStore, listStores, createEnvironment } from '../../commands/store.js';
+
+export const storeCommands: CommandModule = {
+  command: 'store <action>',
+  describe: 'Manage Saleor Cloud stores',
+  builder: (yargs) =>
+    yargs
+      .command({
+        command: 'create',
+        describe: 'Create a new Saleor Cloud store',
+        builder: (yargs) =>
+          yargs
+            .option('name', {
+              alias: 'n',
+              type: 'string',
+              description: 'Store name',
+              demandOption: true,
+            })
+            .option('region', {
+              alias: 'r',
+              type: 'string',
+              description: 'Region (e.g., us-east-1)',
+              default: 'us-east-1',
+            }),
+        handler: async (argv) => {
+          await createStore(argv.name, argv.region);
+        },
+      })
+      .command({
+        command: 'list',
+        describe: 'List your Saleor Cloud stores',
+        builder: (yargs) => yargs,
+        handler: async () => {
+          await listStores();
+        },
+      })
+      .command({
+        command: 'env <action>',
+        describe: 'Manage store environments',
+        builder: (yargs) =>
+          yargs
+            .command({
+              command: 'create',
+              describe: 'Create a new environment',
+              builder: (yargs) =>
+                yargs
+                  .option('store', {
+                    alias: 's',
+                    type: 'string',
+                    description: 'Store ID',
+                    demandOption: true,
+                  })
+                  .option('name', {
+                    alias: 'n',
+                    type: 'string',
+                    description: 'Environment name',
+                    demandOption: true,
+                  }),
+              handler: async (argv) => {
+                await createEnvironment(argv.store as string, argv.name as string);
+              },
+            }),
+      }),
+};

package/src/cli/index.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { storeCommands } from './commands/store.js';
+import { appCommands } from './commands/app.js';
+import { agentCommands } from './commands/agent.js';
+import { configCommands } from './commands/config.js';
+
+yargs(hideBin(process.argv))
+  .command(storeCommands)
+  .command(appCommands)
+  .command(agentCommands)
+  .command(configCommands)
+  .demandCommand(1, 'You must provide a command')
+  .strict()
+  .parse();