dantelabs-agentic-school 1.2.1 → 1.3.0

package/.claude-plugin/marketplace.json

@@ -62,7 +62,7 @@
     },
     {
       "name": "market-research",
-      "description": "시장 분석 리포트 및 데이터 시각화를 생성합니다.",
+      "description": "시장 규모/성장률 분석, Porter's 5 Forces, 경쟁 환경 분석 등 종합적인 시장 조사를 수행합니다. TAM/SAM/SOM 모델링, PESTLE 분석, 경쟁사 포지셔닝 맵 등을 포함합니다.",
       "version": "1.0.0",
       "source": "./plugins/market-research"
     }

package/README.md

@@ -61,6 +61,38 @@ npx dantelabs-agentic-school uninstall brand-analytics
 | `-v, --verbose` | 상세 정보 표시 |
 | `-l, --lang` | 언어 설정 (en, ko) - 기본: en |
 
+### 샘플 다운로드
+
+학습용 샘플 파일을 다운로드하여 마케팅 자동화 파이프라인을 직접 체험해볼 수 있습니다.
+
+```bash
+# 사용 가능한 샘플 목록 보기
+npx dantelabs-agentic-school sample --list
+
+# 특정 샘플 다운로드
+npx dantelabs-agentic-school sample marketing
+
+# 전체 샘플 다운로드
+npx dantelabs-agentic-school sample --all
+
+# 다운로드 경로 지정
+npx dantelabs-agentic-school sample marketing --path ./my-project
+
+# 기존 파일 덮어쓰기
+npx dantelabs-agentic-school sample marketing --force
+```
+
+샘플을 다운로드하면 `samples/` 폴더에 학습 자료가 저장됩니다:
+
+```text
+samples/
+└── marketing/
+    ├── dante-coffee-agentic-marketing-scenario.md  # 마케팅 시나리오 가이드
+    └── dante-coffee-brand-brief.md                 # 브랜드 브리프 예시
+```
+
+> **Tip**: 다운로드한 브랜드 브리프를 사용하여 `/analyze-brand --brand-doc ./samples/marketing/dante-coffee-brand-brief.md` 명령어로 전체 파이프라인을 실행해볼 수 있습니다.
+
 ### Claude Code에서 플러그인 사용
 
 #### 방법 1: 프로젝트별 설치 (권장)
@@ -117,6 +149,36 @@ npx dantelabs-agentic-school install --path ~
 claude
 ```
 
+#### 방법 4: Claude Code 세션 내 마켓플레이스 설치
+
+Claude Code 실행 중 슬래시 명령어로 직접 마켓플레이스를 등록하고 플러그인을 설치할 수 있습니다.
+
+**1. 마켓플레이스 추가**
+
+```bash
+# GitHub 저장소로 추가
+/plugin marketplace add dandacompany/dantelabs-agentic-school
+```
+
+**2. 플러그인 설치**
+
+```bash
+# 특정 플러그인 설치
+/plugin install brand-analytics@dantelabs-agentic-school
+
+# 또는 /plugin 실행 후 Discover 탭에서 검색하여 설치
+/plugin
+```
+
+**3. 설치된 플러그인 확인**
+
+```bash
+# 플러그인 목록 확인
+/plugin
+```
+
+> **Tip**: `/plugin` 명령어 실행 후 **Discover** 탭에서 마켓플레이스의 모든 플러그인을 검색하고 설치할 수 있습니다.
+
 ### 플러그인 사용 확인
 
 Claude Code 실행 후 `/help` 명령어로 설치된 커맨드를 확인할 수 있습니다:

package/cli/bin/cli.js

@@ -11,6 +11,7 @@ import installCommand from '../src/commands/install.js';
 import listCommand from '../src/commands/list.js';
 import infoCommand from '../src/commands/info.js';
 import uninstallCommand from '../src/commands/uninstall.js';
+import sampleCommand from '../src/commands/sample.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -62,6 +63,10 @@ ${chalk.bold(t('cli.examples'))}
   ${chalk.gray(t('cli.showPluginInfo'))}
   $ npx dantelabs-agentic-school info brand-analytics
 
+  ${chalk.gray('# Download samples')}
+  $ npx dantelabs-agentic-school sample marketing
+  $ npx dantelabs-agentic-school sample --all
+
   ${chalk.gray('# Korean language')}
   $ npx dantelabs-agentic-school --lang ko list
 
@@ -73,6 +78,7 @@ installCommand(program);
 listCommand(program);
 infoCommand(program);
 uninstallCommand(program);
+sampleCommand(program);
 
 // Parse arguments
 program.parse();

package/cli/src/commands/sample.js

@@ -0,0 +1,259 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { mkdir, writeFile, readFile, readdir, cp } from 'fs/promises';
+import { join, dirname } from 'path';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { GITHUB_CONFIG } from '../lib/config.js';
+import { fetchFile, getDirectoryContents } from '../lib/downloader.js';
+import logger from '../utils/logger.js';
+import { t } from '../i18n/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_ROOT = join(__dirname, '../../..');
+
+/**
+ * Check if local samples directory exists
+ */
+function hasLocalSamples() {
+  return existsSync(join(PACKAGE_ROOT, 'samples'));
+}
+
+/**
+ * Get list of available samples (local or remote)
+ */
+async function getAvailableSamples() {
+  if (hasLocalSamples()) {
+    const samplesDir = join(PACKAGE_ROOT, 'samples');
+    const entries = await readdir(samplesDir, { withFileTypes: true });
+    return entries.filter(e => e.isDirectory()).map(e => e.name);
+  }
+
+  // Fallback to remote
+  const contents = await getDirectoryContents('samples');
+  return contents
+    .filter(item => item.type === 'dir')
+    .map(item => item.name);
+}
+
+/**
+ * Copy local sample folder recursively
+ */
+async function copyLocalSampleFolder(sampleName, targetDir, options = {}) {
+  const { onFile } = options;
+  const localPath = join(PACKAGE_ROOT, 'samples', sampleName);
+
+  if (!existsSync(localPath)) {
+    throw new Error(t('sample.notFound', { name: sampleName }));
+  }
+
+  // Create target directory
+  await mkdir(targetDir, { recursive: true });
+
+  let fileCount = 0;
+
+  async function copyRecursive(srcDir, destDir) {
+    const entries = await readdir(srcDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = join(srcDir, entry.name);
+      const destPath = join(destDir, entry.name);
+
+      if (entry.isDirectory()) {
+        await mkdir(destPath, { recursive: true });
+        await copyRecursive(srcPath, destPath);
+      } else {
+        const content = await readFile(srcPath);
+        await writeFile(destPath, content);
+        fileCount++;
+
+        if (onFile) {
+          onFile(entry.name);
+        }
+      }
+    }
+  }
+
+  await copyRecursive(localPath, targetDir);
+  return fileCount;
+}
+
+/**
+ * Download a sample folder from remote
+ */
+async function downloadRemoteSampleFolder(sampleName, targetDir, options = {}) {
+  const { onFile } = options;
+  const remotePath = `samples/${sampleName}`;
+  const contents = await getDirectoryContents(remotePath);
+
+  if (contents.length === 0) {
+    throw new Error(t('sample.notFound', { name: sampleName }));
+  }
+
+  // Create target directory
+  await mkdir(targetDir, { recursive: true });
+
+  let fileCount = 0;
+
+  for (const item of contents) {
+    if (item.type === 'file') {
+      const content = await fetchFile(item.path);
+      const filePath = join(targetDir, item.name);
+      await writeFile(filePath, content);
+      fileCount++;
+
+      if (onFile) {
+        onFile(item.name);
+      }
+    } else if (item.type === 'dir') {
+      // Recursively download subdirectories
+      const subDir = join(targetDir, item.name);
+      const subResult = await downloadRemoteSampleFolder(
+        `${sampleName}/${item.name}`,
+        subDir,
+        options
+      );
+      fileCount += subResult;
+    }
+  }
+
+  return fileCount;
+}
+
+/**
+ * Download or copy a sample folder (local or remote)
+ */
+async function downloadSampleFolder(sampleName, targetDir, options = {}) {
+  if (hasLocalSamples()) {
+    return copyLocalSampleFolder(sampleName, targetDir, options);
+  }
+  return downloadRemoteSampleFolder(sampleName, targetDir, options);
+}
+
+export default function sampleCommand(program) {
+  program
+    .command('sample [name]')
+    .description(t('sample.description'))
+    .option('-a, --all', t('sample.optionAll'))
+    .option('-l, --list', t('sample.optionList'))
+    .option('-p, --path <path>', t('sample.optionPath'), '.')
+    .option('-f, --force', t('sample.optionForce'))
+    .action(async (name, options) => {
+      try {
+        const targetBase = options.path;
+
+        // List available samples
+        if (options.list || (!name && !options.all)) {
+          const spinner = ora(t('sample.fetchingList')).start();
+
+          try {
+            const samples = await getAvailableSamples();
+            spinner.stop();
+
+            console.log();
+            console.log(chalk.bold.blue(t('sample.availableTitle')));
+            console.log(chalk.gray('━'.repeat(50)));
+            console.log();
+
+            if (samples.length === 0) {
+              console.log(chalk.yellow(t('sample.noSamples')));
+            } else {
+              for (const sample of samples) {
+                console.log(`  ${chalk.cyan('•')} ${sample}`);
+              }
+              console.log();
+              console.log(chalk.gray(t('sample.downloadHint')));
+              console.log(chalk.gray(t('sample.downloadAllHint')));
+            }
+            console.log();
+          } catch (error) {
+            spinner.fail(t('sample.fetchError'));
+            throw error;
+          }
+          return;
+        }
+
+        // Download all samples
+        if (options.all) {
+          const spinner = ora(t('sample.fetchingList')).start();
+          const samples = await getAvailableSamples();
+          spinner.stop();
+
+          if (samples.length === 0) {
+            logger.warn(t('sample.noSamples'));
+            return;
+          }
+
+          console.log();
+          console.log(chalk.bold.blue(t('sample.downloadingAll', { count: samples.length })));
+          console.log();
+
+          let totalFiles = 0;
+
+          for (const sampleName of samples) {
+            const targetDir = join(targetBase, 'samples', sampleName);
+
+            if (!options.force && existsSync(targetDir)) {
+              logger.warn(t('sample.alreadyExists', { name: sampleName }));
+              continue;
+            }
+
+            const downloadSpinner = ora(t('sample.downloading', { name: sampleName })).start();
+
+            try {
+              const fileCount = await downloadSampleFolder(sampleName, targetDir, {
+                onFile: (fileName) => {
+                  downloadSpinner.text = t('sample.downloadingFile', { name: sampleName, file: fileName });
+                }
+              });
+
+              downloadSpinner.succeed(
+                t('sample.downloadedFiles', { name: sampleName, count: fileCount })
+              );
+              totalFiles += fileCount;
+            } catch (error) {
+              downloadSpinner.fail(t('sample.downloadFailed', { name: sampleName }));
+              logger.error(error.message);
+            }
+          }
+
+          console.log();
+          console.log(chalk.green(t('sample.allComplete', { count: totalFiles })));
+          console.log(chalk.gray(t('sample.savedTo', { path: join(targetBase, 'samples') })));
+          console.log();
+          return;
+        }
+
+        // Download specific sample
+        const targetDir = join(targetBase, 'samples', name);
+
+        if (!options.force && existsSync(targetDir)) {
+          logger.error(t('sample.alreadyExistsError', { path: targetDir }));
+          console.log(chalk.gray(t('sample.useForceHint')));
+          process.exit(1);
+        }
+
+        const spinner = ora(t('sample.downloading', { name })).start();
+
+        try {
+          const fileCount = await downloadSampleFolder(name, targetDir, {
+            onFile: (fileName) => {
+              spinner.text = t('sample.downloadingFile', { name, file: fileName });
+            }
+          });
+
+          spinner.succeed(t('sample.downloadedFiles', { name, count: fileCount }));
+          console.log();
+          console.log(chalk.gray(t('sample.savedTo', { path: targetDir })));
+          console.log();
+        } catch (error) {
+          spinner.fail(t('sample.downloadFailed', { name }));
+          throw error;
+        }
+      } catch (error) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+    });
+}

package/cli/src/i18n/locales/en.js

@@ -96,6 +96,32 @@ export default {
     removedSummary: 'Removed: {agents} agents, {commands} commands, {skills} skills'
   },
 
+  // Sample command
+  sample: {
+    description: 'Download sample files for learning',
+    optionAll: 'Download all samples',
+    optionList: 'List available samples',
+    optionPath: 'Download path (default: current directory)',
+    optionForce: 'Force overwrite existing files',
+    fetchingList: 'Fetching sample list...',
+    availableTitle: 'Available Samples',
+    noSamples: 'No samples available',
+    downloadHint: 'Download: npx dantelabs-agentic-school sample <name>',
+    downloadAllHint: 'Download all: npx dantelabs-agentic-school sample --all',
+    downloadingAll: 'Downloading all {count} samples...',
+    downloading: 'Downloading {name}...',
+    downloadingFile: 'Downloading {name}: {file}',
+    downloadedFiles: 'Downloaded {name} ({count} files)',
+    downloadFailed: 'Failed to download {name}',
+    allComplete: 'All samples downloaded ({count} files total)',
+    savedTo: 'Saved to: {path}',
+    alreadyExists: 'Skipping {name} (already exists, use --force to overwrite)',
+    alreadyExistsError: 'Directory already exists: {path}',
+    useForceHint: 'Use --force to overwrite existing files',
+    notFound: "Sample '{name}' not found",
+    fetchError: 'Failed to fetch sample list'
+  },
+
   // Logger
   logger: {
     info: 'info',

package/cli/src/i18n/locales/ko.js

@@ -96,6 +96,32 @@ export default {
     removedSummary: '삭제됨: 에이전트 {agents}개, 명령어 {commands}개, 스킬 {skills}개'
   },
 
+  // Sample command
+  sample: {
+    description: '학습용 샘플 파일 다운로드',
+    optionAll: '모든 샘플 다운로드',
+    optionList: '사용 가능한 샘플 목록',
+    optionPath: '다운로드 경로 (기본: 현재 디렉토리)',
+    optionForce: '기존 파일 강제 덮어쓰기',
+    fetchingList: '샘플 목록 불러오는 중...',
+    availableTitle: '사용 가능한 샘플',
+    noSamples: '사용 가능한 샘플이 없습니다',
+    downloadHint: '다운로드: npx dantelabs-agentic-school sample <이름>',
+    downloadAllHint: '전체 다운로드: npx dantelabs-agentic-school sample --all',
+    downloadingAll: '전체 {count}개 샘플 다운로드 중...',
+    downloading: '{name} 다운로드 중...',
+    downloadingFile: '{name} 다운로드 중: {file}',
+    downloadedFiles: '{name} 다운로드 완료 ({count}개 파일)',
+    downloadFailed: '{name} 다운로드 실패',
+    allComplete: '전체 샘플 다운로드 완료 (총 {count}개 파일)',
+    savedTo: '저장 위치: {path}',
+    alreadyExists: '{name} 건너뜀 (이미 존재함, --force로 덮어쓰기 가능)',
+    alreadyExistsError: '디렉토리가 이미 존재합니다: {path}',
+    useForceHint: '기존 파일을 덮어쓰려면 --force 옵션을 사용하세요',
+    notFound: "샘플 '{name}'을(를) 찾을 수 없습니다",
+    fetchError: '샘플 목록을 불러오는 데 실패했습니다'
+  },
+
   // Logger
   logger: {
     info: '정보',

package/cli/src/lib/config.js

@@ -17,7 +17,7 @@ const CACHE_TTL = 1000 * 60 * 60; // 1 hour
 export const GITHUB_CONFIG = {
   owner: 'dandacompany',
   repo: 'dantelabs-agentic-school',
-  branch: 'main',
+  branch: 'master',
   get rawBase() {
     return `https://raw.githubusercontent.com/${this.owner}/${this.repo}/${this.branch}`;
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dantelabs-agentic-school",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "CLI tool for installing Dante Labs agentic plugins for Claude Code",
   "main": "cli/src/index.js",
   "type": "module",
@@ -42,6 +42,7 @@
   "files": [
     "cli/",
     "plugins/",
+    "samples/",
     ".claude-plugin/"
   ],
   "dependencies": {

package/plugins/market-research/agents/competitive-intelligence.md

@@ -0,0 +1,171 @@
+---
+name: competitive-intelligence
+description: 경쟁 환경 및 산업 구조를 분석하는 경쟁 인텔리전스 에이전트
+when_to_use: |
+  이 에이전트는 다음 상황에서 사용합니다:
+  - "경쟁 환경 분석해줘", "경쟁사 조사해줘"
+  - "Porter's 5 Forces 분석", "산업 구조 분석"
+  - "경쟁사 포지셔닝 맵", "경쟁 강도 분석"
+  - 산업 수준의 경쟁 환경 파악이 필요할 때
+---
+
+# Competitive Intelligence Agent
+
+산업 수준의 경쟁 환경과 구조를 분석하는 전문 에이전트입니다.
+
+## Role & Expertise
+
+### Primary Role
+- Porter's Five Forces 분석
+- 경쟁사 포지셔닝 분석
+- 산업 구조 분석
+- 경쟁 강도 평가
+
+### Core Skills
+- 산업 구조 분석
+- 경쟁사 벤치마킹
+- 포지셔닝 맵 작성
+- 진입 장벽 평가
+
+## Analysis Framework
+
+### 1. Porter's Five Forces
+
+```
+                ┌─────────────────┐
+                │  신규 진입자    │
+                │    위협        │
+                └────────┬────────┘
+                         │
+                         ▼
+┌──────────────┐  ┌──────────────┐  ┌──────────────┐
+│ 공급자 교섭력 │◀─│  산업 내     │─▶│ 구매자 교섭력 │
+│              │  │   경쟁       │  │              │
+└──────────────┘  └───────┬──────┘  └──────────────┘
+                          │
+                          ▼
+                ┌─────────────────┐
+                │   대체재 위협   │
+                └─────────────────┘
+```
+
+각 요인별 평가 기준:
+- **HIGH**: 강한 위협/압력
+- **MEDIUM**: 중간 수준
+- **LOW**: 낮은 위협/압력
+
+### 2. 경쟁사 포지셔닝 매트릭스
+
+```
+           High
+    가격   │    ● Premium
+           │         Leaders
+           │
+           │    ★ Target
+           │      Position
+           │
+    Low    │ ● Low-cost
+           │   Players
+           └──────────────────
+              Low   품질/가치   High
+```
+
+### 3. 경쟁 강도 분석
+
+| 요소 | 평가 항목 |
+|------|----------|
+| 경쟁자 수 | 시장 내 경쟁사 수 |
+| 성장률 | 시장 성장 속도 |
+| 차별화 | 제품/서비스 차별화 정도 |
+| 전환 비용 | 고객 전환 비용 |
+| 퇴출 장벽 | 시장 퇴출의 어려움 |
+
+## Output Format
+
+### 경쟁 환경 분석 리포트
+
+```markdown
+# 경쟁 환경 분석: [산업명]
+
+## Executive Summary
+> [핵심 발견 사항]
+
+## 1. Porter's Five Forces 분석
+
+### 1.1 산업 내 경쟁 (Industry Rivalry): [HIGH/MEDIUM/LOW]
+- 현황: [분석]
+- 주요 경쟁사: [리스트]
+- 경쟁 요인: [요인들]
+
+### 1.2 신규 진입자 위협: [HIGH/MEDIUM/LOW]
+- 진입 장벽: [분석]
+- 필요 자본: [수준]
+- 규제 환경: [분석]
+
+### 1.3 대체재 위협: [HIGH/MEDIUM/LOW]
+- 대체재 유형: [리스트]
+- 가격/성능 비교: [분석]
+
+### 1.4 공급자 교섭력: [HIGH/MEDIUM/LOW]
+- 공급자 집중도: [분석]
+- 전환 비용: [분석]
+
+### 1.5 구매자 교섭력: [HIGH/MEDIUM/LOW]
+- 구매자 특성: [분석]
+- 가격 민감도: [분석]
+
+## 2. 경쟁사 포지셔닝
+
+| 경쟁사 | 포지션 | 가격대 | 주요 강점 | 시장 점유율 |
+|--------|--------|--------|----------|------------|
+| A사 | ... | ... | ... | ...% |
+| B사 | ... | ... | ... | ...% |
+
+### 포지셔닝 맵
+[2x2 매트릭스 설명]
+
+## 3. 전략적 기회
+
+### 빈 공간 (White Space)
+- [기회 영역 1]
+- [기회 영역 2]
+
+### 차별화 기회
+- [차별화 포인트 1]
+- [차별화 포인트 2]
+
+## 4. 핵심 시사점
+- [시사점 1]
+- [시사점 2]
+- [시사점 3]
+```
+
+## Usage
+
+### 직접 호출
+```
+"한국 커피 시장의 경쟁 환경을 분석해줘"
+"Porter's 5 Forces로 산업 구조를 분석해줘"
+"경쟁사 포지셔닝 맵을 만들어줘"
+```
+
+### 커맨드 연동
+```bash
+/competitive-landscape --market "Korean coffee retail"
+```
+
+## Related Skills
+
+- `analysis-reports`: 분석 리포트 템플릿
+- `diagram-generator`: Porter's 5 Forces, 포지셔닝 맵 시각화
+
+## Related Agents
+
+- `market-analyst`: 시장 규모 및 성장 분석
+- `competitive-analyst`: 개별 경쟁사 심층 분석 (brand-analytics)
+
+## Notes
+
+> **competitive-intelligence vs competitive-analyst**
+> - `competitive-intelligence` (market-research): 산업 수준의 경쟁 구조 분석
+> - `competitive-analyst` (brand-analytics): 개별 브랜드 관점의 경쟁사 분석