@colin4k1024/tsp 2.5.2 → 2.5.3

package/scripts/lib/install-targets/cangming-home.js

@@ -0,0 +1,143 @@
+const fs = require('fs');
+const path = require('path');
+
+const {
+  createInstallTargetAdapter,
+  createManagedOperation,
+  normalizeRelativePath,
+} = require('./helpers');
+
+const PLUGIN_NAME = require('../team-skills-data.json').plugin.name;
+
+function addOperation(operations, seen, operation) {
+  const key = `${operation.sourceRelativePath}=>${operation.destinationPath}`;
+  if (seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  operations.push(operation);
+}
+
+function addCopyOperation(operations, seen, moduleId, sourceRelativePath, destinationPath, strategy = 'preserve-relative-path') {
+  addOperation(operations, seen, createManagedOperation({
+    moduleId,
+    sourceRelativePath,
+    destinationPath,
+    strategy,
+  }));
+}
+
+function sourceDir(input, sourceRelativePath) {
+  return path.join(input.repoRoot || '', normalizeRelativePath(sourceRelativePath));
+}
+
+function rootAgentFileName(sourcePath, fileName) {
+  const normalizedSourcePath = normalizeRelativePath(sourcePath);
+  if (normalizedSourcePath === 'agents/specialists' || normalizedSourcePath.startsWith('agents/specialists/')) {
+    return `specialist-${fileName}`;
+  }
+  return fileName;
+}
+
+function addRootAgentOperations(operations, seen, moduleId, sourceRelativePath, input, targetRoot) {
+  const normalizedSourcePath = normalizeRelativePath(sourceRelativePath);
+  if (normalizedSourcePath !== 'agents' && !normalizedSourcePath.startsWith('agents/')) {
+    return;
+  }
+
+  const agentDirs = normalizedSourcePath === 'agents'
+    ? ['roles', 'specialists']
+    : [''];
+
+  for (const agentDir of agentDirs) {
+    const sourcePath = agentDir ? path.join(normalizedSourcePath, agentDir) : normalizedSourcePath;
+    const absoluteSourceDir = sourceDir(input, sourcePath);
+    if (!input.repoRoot || !fs.existsSync(absoluteSourceDir)) {
+      continue;
+    }
+
+    const stat = fs.statSync(absoluteSourceDir);
+    if (stat.isFile() && path.extname(absoluteSourceDir) === '.md') {
+      const fileName = rootAgentFileName(path.dirname(sourcePath), path.basename(sourcePath));
+      addCopyOperation(
+        operations,
+        seen,
+        moduleId,
+        sourcePath,
+        path.join(targetRoot, 'agents', fileName),
+        'flatten-agent-copy'
+      );
+      continue;
+    }
+
+    if (!stat.isDirectory()) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(absoluteSourceDir, { withFileTypes: true }).sort((left, right) => (
+      left.name.localeCompare(right.name)
+    ))) {
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        const fileName = rootAgentFileName(sourcePath, entry.name);
+        addCopyOperation(
+          operations,
+          seen,
+          moduleId,
+          path.join(sourcePath, entry.name),
+          path.join(targetRoot, 'agents', fileName),
+          'flatten-agent-copy'
+        );
+      }
+    }
+  }
+}
+
+function planCangmingOperations(input, adapter) {
+  const targetRoot = adapter.resolveRoot(input);
+  const pluginRoot = path.join(targetRoot, 'plugins', PLUGIN_NAME);
+  const operations = [];
+  const seen = new Set();
+
+  for (const module of Array.isArray(input.modules) ? input.modules : []) {
+    for (const rawSourcePath of Array.isArray(module.paths) ? module.paths : []) {
+      const sourceRelativePath = normalizeRelativePath(rawSourcePath);
+
+      addCopyOperation(
+        operations,
+        seen,
+        module.id,
+        sourceRelativePath,
+        path.join(pluginRoot, sourceRelativePath),
+        'plugin-copy'
+      );
+
+      if (sourceRelativePath === 'commands' || sourceRelativePath.startsWith('commands/')) {
+        const commandSuffix = sourceRelativePath === 'commands'
+          ? ''
+          : sourceRelativePath.slice('commands/'.length);
+        addCopyOperation(
+          operations,
+          seen,
+          module.id,
+          sourceRelativePath,
+          path.join(targetRoot, 'command', commandSuffix),
+          'opencode-command-copy'
+        );
+      }
+
+      addRootAgentOperations(operations, seen, module.id, sourceRelativePath, input, targetRoot);
+    }
+  }
+
+  return operations;
+}
+
+module.exports = createInstallTargetAdapter({
+  id: 'cangming-home',
+  target: 'cangming',
+  kind: 'home',
+  rootSegments: ['.config', 'cangming'],
+  installStatePathSegments: ['ecc-install-state.json'],
+  nativeRootRelativePath: '.cangming',
+  planOperations: planCangmingOperations,
+});

package/scripts/lib/install-targets/codewhale-home.js

@@ -0,0 +1,187 @@
+const fs = require('fs');
+const path = require('path');
+
+const {
+  createInstallTargetAdapter,
+  createManagedOperation,
+  normalizeRelativePath,
+} = require('./helpers');
+
+const PLUGIN_NAME = require('../team-skills-data.json').plugin.name;
+
+function addOperation(operations, seen, operation) {
+  const key = `${operation.sourceRelativePath}=>${operation.destinationPath}`;
+  if (seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  operations.push(operation);
+}
+
+function addCopyOperation(operations, seen, moduleId, sourceRelativePath, destinationPath, strategy = 'preserve-relative-path') {
+  addOperation(operations, seen, createManagedOperation({
+    moduleId,
+    sourceRelativePath,
+    destinationPath,
+    strategy,
+  }));
+}
+
+function sourceDir(input, sourceRelativePath) {
+  return path.join(input.repoRoot || '', normalizeRelativePath(sourceRelativePath));
+}
+
+function addAgentOperations(operations, seen, moduleId, sourceRelativePath, input, targetRoot) {
+  const normalizedSourcePath = normalizeRelativePath(sourceRelativePath);
+  if (normalizedSourcePath !== 'agents' && !normalizedSourcePath.startsWith('agents/')) {
+    return;
+  }
+
+  const agentDirs = normalizedSourcePath === 'agents'
+    ? ['roles', 'specialists']
+    : [''];
+
+  for (const agentDir of agentDirs) {
+    const sourcePath = agentDir ? path.join(normalizedSourcePath, agentDir) : normalizedSourcePath;
+    const absoluteSourceDir = sourceDir(input, sourcePath);
+    if (!input.repoRoot || !fs.existsSync(absoluteSourceDir)) {
+      continue;
+    }
+
+    const stat = fs.statSync(absoluteSourceDir);
+    if (stat.isFile() && path.extname(absoluteSourceDir) === '.md') {
+      const fileName = path.basename(sourcePath);
+      addCopyOperation(
+        operations, seen, moduleId, sourcePath,
+        path.join(targetRoot, 'agents', fileName),
+        'flatten-agent-copy'
+      );
+      continue;
+    }
+
+    if (!stat.isDirectory()) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(absoluteSourceDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        const prefix = agentDir === 'specialists' ? 'specialist-' : '';
+        addCopyOperation(
+          operations, seen, moduleId,
+          path.join(sourcePath, entry.name),
+          path.join(targetRoot, 'agents', `${prefix}${entry.name}`),
+          'flatten-agent-copy'
+        );
+      }
+    }
+  }
+}
+
+function addRuleOperations(operations, seen, moduleId, sourceRelativePath, input, targetRoot) {
+  const normalizedSourcePath = normalizeRelativePath(sourceRelativePath);
+  if (normalizedSourcePath !== 'rules' && !normalizedSourcePath.startsWith('rules/')) {
+    return;
+  }
+
+  const absoluteSourceDir = sourceDir(input, normalizedSourcePath);
+  if (!input.repoRoot || !fs.existsSync(absoluteSourceDir) || !fs.statSync(absoluteSourceDir).isDirectory()) {
+    return;
+  }
+
+  const entries = fs.readdirSync(absoluteSourceDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const entryPath = path.join(absoluteSourceDir, entry.name);
+    if (entry.isDirectory()) {
+      const subEntries = fs.readdirSync(entryPath, { withFileTypes: true });
+      for (const sub of subEntries) {
+        if (sub.isFile() && sub.name.endsWith('.md')) {
+          addCopyOperation(
+            operations, seen, moduleId,
+            path.join(normalizedSourcePath, entry.name, sub.name),
+            path.join(targetRoot, 'rules', entry.name, sub.name),
+            'rule-copy'
+          );
+        }
+      }
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      addCopyOperation(
+        operations, seen, moduleId,
+        path.join(normalizedSourcePath, entry.name),
+        path.join(targetRoot, 'rules', entry.name),
+        'rule-copy'
+      );
+    }
+  }
+}
+
+function planCodeWhaleOperations(input, adapter) {
+  const targetRoot = adapter.resolveRoot(input);
+  const operations = [];
+  const seen = new Set();
+
+  for (const module of Array.isArray(input.modules) ? input.modules : []) {
+    for (const rawSourcePath of Array.isArray(module.paths) ? module.paths : []) {
+      const sourceRelativePath = normalizeRelativePath(rawSourcePath);
+
+      // Skills: preserve directory structure
+      if (sourceRelativePath === 'skills' || sourceRelativePath.startsWith('skills/')) {
+        addCopyOperation(
+          operations, seen, module.id, sourceRelativePath,
+          path.join(targetRoot, 'skills', sourceRelativePath.replace(/^skills\/?/, '')),
+          'skill-copy'
+        );
+      }
+
+      // Commands: flatten to commands/
+      if (sourceRelativePath === 'commands' || sourceRelativePath.startsWith('commands/')) {
+        const commandSuffix = sourceRelativePath === 'commands'
+          ? ''
+          : sourceRelativePath.slice('commands/'.length);
+        addCopyOperation(
+          operations, seen, module.id, sourceRelativePath,
+          path.join(targetRoot, 'commands', commandSuffix),
+          'command-copy'
+        );
+      }
+
+      // Agents: flatten roles + specialists
+      addAgentOperations(operations, seen, module.id, sourceRelativePath, input, targetRoot);
+
+      // Rules: preserve namespace/file structure
+      addRuleOperations(operations, seen, module.id, sourceRelativePath, input, targetRoot);
+
+      // Contexts: direct copy
+      if (sourceRelativePath === 'contexts' || sourceRelativePath.startsWith('contexts/')) {
+        const contextSuffix = sourceRelativePath === 'contexts'
+          ? ''
+          : sourceRelativePath.slice('contexts/'.length);
+        addCopyOperation(
+          operations, seen, module.id, sourceRelativePath,
+          path.join(targetRoot, 'contexts', contextSuffix),
+          'context-copy'
+        );
+      }
+
+      // Hooks: copy hooks directory for reference, config.toml injection handled by post-install
+      if (sourceRelativePath === 'hooks' || sourceRelativePath.startsWith('hooks/')) {
+        addCopyOperation(
+          operations, seen, module.id, sourceRelativePath,
+          path.join(targetRoot, 'hooks', sourceRelativePath.replace(/^hooks\/?/, '')),
+          'hook-copy'
+        );
+      }
+    }
+  }
+
+  return operations;
+}
+
+module.exports = createInstallTargetAdapter({
+  id: 'codewhale-home',
+  target: 'codewhale',
+  kind: 'home',
+  rootSegments: ['.codewhale'],
+  installStatePathSegments: ['ecc-install-state.json'],
+  nativeRootRelativePath: '.codewhale',
+  planOperations: planCodeWhaleOperations,
+});

package/scripts/lib/install-targets/registry.js

@@ -1,15 +1,17 @@
 const antigravityProject = require('./antigravity-project');
 const augmentProject = require('./augment-project');
+const cangmingHome = require('./cangming-home');
 const claudeHome = require('./claude-home');
 const codebuddyProject = require('./codebuddy-project');
 const codexHome = require('./codex-home');
+const codewhaleHome = require('./codewhale-home');
 const copilotHome = require('./copilot-home');
 const cursorProject = require('./cursor-project');
 const geminiProject = require('./gemini-project');
 const opencodeHome = require('./opencode-home');
 const windsurfProject = require('./windsurf-project');
 
-const PUBLIC_INSTALL_TARGETS = Object.freeze(['claude', 'codex', 'opencode']);
+const PUBLIC_INSTALL_TARGETS = Object.freeze(['claude', 'codex', 'opencode', 'cangming', 'codewhale']);
 const TARGET_ALIASES = Object.freeze({
   'claude-code': 'claude',
   claudecode: 'claude',
@@ -22,6 +24,8 @@ const ADAPTERS = Object.freeze([
   codexHome,
   geminiProject,
   opencodeHome,
+  cangmingHome,
+  codewhaleHome,
   codebuddyProject,
   copilotHome,
   windsurfProject,

package/scripts/lib/transcript-usage.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_CONTEXT_LIMIT = 200000;
+const EXTENDED_CONTEXT_LIMIT = 1000000;
+const DEFAULT_TAIL_BYTES = 65536;
+const EXPANDED_TAIL_BYTES = 262144;
+
+function resolveContextLimit(modelId) {
+  const envLimit = Number(process.env.CLAUDE_CONTEXT_LIMIT);
+  if (Number.isFinite(envLimit) && envLimit > 0) return envLimit;
+
+  if (typeof modelId === 'string' && /\[1[mM]\]/i.test(modelId)) {
+    return EXTENDED_CONTEXT_LIMIT;
+  }
+
+  return DEFAULT_CONTEXT_LIMIT;
+}
+
+function readTailLines(filePath, tailBytes = DEFAULT_TAIL_BYTES) {
+  let fd;
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) return [];
+
+    const readSize = Math.min(tailBytes, stat.size);
+    const buffer = Buffer.alloc(readSize);
+    fd = fs.openSync(filePath, 'r');
+    fs.readSync(fd, buffer, 0, readSize, stat.size - readSize);
+    fs.closeSync(fd);
+    fd = null;
+
+    const text = buffer.toString('utf8');
+    const lines = text.split('\n');
+
+    // Drop the first line if we started mid-file (likely partial)
+    if (stat.size > readSize && lines.length > 0) {
+      lines.shift();
+    }
+
+    return lines.filter(line => line.trim().length > 0);
+  } catch (_) {
+    if (fd != null) try { fs.closeSync(fd); } catch (__) { /* ignore */ }
+    return [];
+  }
+}
+
+function normalizeUsage(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+
+  const inputTokens = Number(raw.input_tokens || raw.prompt_tokens || 0) || 0;
+  const outputTokens = Number(raw.output_tokens || raw.completion_tokens || 0) || 0;
+  const cacheCreationTokens = Number(raw.cache_creation_input_tokens || raw.cache_creation_prompt_tokens || 0) || 0;
+  const cacheReadTokens = Number(raw.cache_read_input_tokens || raw.cache_read_prompt_tokens || raw.cached_tokens || 0) || 0;
+
+  const contextTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+  if (contextTokens === 0) return null;
+
+  return {
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    contextTokens,
+  };
+}
+
+function parseTranscriptUsage(transcriptPath) {
+  if (!transcriptPath || typeof transcriptPath !== 'string') return null;
+  if (!fs.existsSync(transcriptPath)) return null;
+
+  let lines = readTailLines(transcriptPath, DEFAULT_TAIL_BYTES);
+
+  // Scan from bottom up for the last assistant message with usage
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch (_) {
+      continue;
+    }
+
+    // Handle summary entries — they indicate compaction happened
+    if (entry.type === 'summary' && entry.leafUuid) {
+      const projectDir = path.dirname(transcriptPath);
+      const usage = findUsageByLeafUuid(entry.leafUuid, projectDir);
+      if (usage) return usage;
+      continue;
+    }
+
+    if (entry.type !== 'assistant') continue;
+    if (!entry.message || !entry.message.usage) continue;
+
+    return normalizeUsage(entry.message.usage);
+  }
+
+  // If not found in default tail, try expanded read
+  if (lines.length > 0) {
+    lines = readTailLines(transcriptPath, EXPANDED_TAIL_BYTES);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line) continue;
+
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (_) {
+        continue;
+      }
+
+      if (entry.type !== 'assistant') continue;
+      if (!entry.message || !entry.message.usage) continue;
+
+      return normalizeUsage(entry.message.usage);
+    }
+  }
+
+  return null;
+}
+
+function findUsageByLeafUuid(leafUuid, projectDir) {
+  if (!projectDir || !fs.existsSync(projectDir)) return null;
+
+  let sessionFiles;
+  try {
+    sessionFiles = fs.readdirSync(projectDir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => path.join(projectDir, f));
+  } catch (_) {
+    return null;
+  }
+
+  for (const filePath of sessionFiles) {
+    const lines = readTailLines(filePath, EXPANDED_TAIL_BYTES);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line) continue;
+
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (_) {
+        continue;
+      }
+
+      if (entry.uuid === leafUuid && entry.type === 'assistant' && entry.message?.usage) {
+        return normalizeUsage(entry.message.usage);
+      }
+    }
+  }
+
+  return null;
+}
+
+function resolveTranscriptMetrics(transcriptPath, modelId) {
+  const usage = parseTranscriptUsage(transcriptPath);
+  if (!usage) return null;
+
+  const contextLimit = resolveContextLimit(modelId);
+  const usagePct = Math.max(0, Math.min(100, Math.round((usage.contextTokens / contextLimit) * 100)));
+
+  return {
+    usagePct,
+    contextTokens: usage.contextTokens,
+    contextLimit,
+    source: 'transcript_usage',
+  };
+}
+
+module.exports = {
+  resolveContextLimit,
+  readTailLines,
+  parseTranscriptUsage,
+  resolveTranscriptMetrics,
+  normalizeUsage,
+  DEFAULT_CONTEXT_LIMIT,
+  EXTENDED_CONTEXT_LIMIT,
+};

package/scripts/test-cangming-install.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CANGMING_HOME = path.join(os.homedir(), '.config', 'cangming');
+const PLUGIN_DIR = path.join(CANGMING_HOME, 'plugins', 'team-skills-platform');
+
+console.log('=== Cangming 安装验证 ===\n');
+
+let passed = 0;
+let failed = 0;
+
+function check(description, condition) {
+  if (condition) {
+    console.log(`✅ ${description}`);
+    passed++;
+  } else {
+    console.log(`❌ ${description}`);
+    failed++;
+  }
+}
+
+console.log('📁 目录结构检查:');
+check('CANGMING_HOME 目录存在', fs.existsSync(CANGMING_HOME));
+check('AGENTS.md 文件存在', fs.existsSync(path.join(CANGMING_HOME, 'AGENTS.md')));
+check('agents 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'agents')));
+check('command 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'command')));
+check('plugins 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'plugins')));
+check('team-skills-platform 插件存在', fs.existsSync(PLUGIN_DIR));
+
+console.log('\n📄 文件内容检查:');
+
+const agentsMdPath = path.join(CANGMING_HOME, 'AGENTS.md');
+if (fs.existsSync(agentsMdPath)) {
+  const content = fs.readFileSync(agentsMdPath, 'utf8');
+  check('AGENTS.md 包含团队技能平台标记', content.includes('<!-- team-skills-platform -->'));
+  check('AGENTS.md 包含角色索引', content.includes('## 可用角色'));
+  check('AGENTS.md 包含命令索引', content.includes('## 核心团队命令'));
+  check('AGENTS.md 包含插件根路径', content.includes('## 插件根路径'));
+}
+
+console.log('\n👥 Agents 检查:');
+const agentsDir = path.join(CANGMING_HOME, 'agents');
+if (fs.existsSync(agentsDir)) {
+  const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+  check(`agents 目录包含文件 (${agentFiles.length})`, agentFiles.length > 0);
+
+  const roleAgents = ['tech-lead.md', 'product-manager.md', 'architect.md', 'frontend-engineer.md',
+                      'backend-engineer.md', 'qa-engineer.md', 'devops-engineer.md'];
+  for (const agent of roleAgents) {
+    check(`角色 agent ${agent} 存在`, fs.existsSync(path.join(agentsDir, agent)));
+  }
+
+  const specialistAgents = agentFiles.filter(f => f.startsWith('specialist-'));
+  check(`specialist agents 存在 (${specialistAgents.length})`, specialistAgents.length > 0);
+}
+
+console.log('\n📝 Commands 检查:');
+const commandsDir = path.join(CANGMING_HOME, 'command');
+if (fs.existsSync(commandsDir)) {
+  const commandFiles = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md'));
+  check(`commands 目录包含文件 (${commandFiles.length})`, commandFiles.length > 0);
+
+  const coreCommands = ['team-intake.md', 'team-plan.md', 'team-execute.md', 'team-review.md',
+                        'team-release.md', 'handoff.md'];
+  for (const cmd of coreCommands) {
+    check(`核心命令 ${cmd} 存在`, fs.existsSync(path.join(commandsDir, cmd)));
+  }
+}
+
+console.log('\n🎯 Skills 检查:');
+const skillsDir = path.join(PLUGIN_DIR, 'skills');
+if (fs.existsSync(skillsDir)) {
+  const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+  check(`skills 目录包含目录 (${skillDirs.length})`, skillDirs.length > 0);
+}
+
+console.log('\n📜 Rules 检查:');
+const rulesDir = path.join(PLUGIN_DIR, 'rules');
+if (fs.existsSync(rulesDir)) {
+  const ruleItems = fs.readdirSync(rulesDir);
+  check(`rules 目录包含内容 (${ruleItems.length})`, ruleItems.length > 0);
+  check('common 规则目录存在', fs.existsSync(path.join(rulesDir, 'common')));
+}
+
+// 总结
+console.log('\n=== 测试总结 ===');
+console.log(`通过: ${passed}`);
+console.log(`失败: ${failed}`);
+console.log(`总计: ${passed + failed}`);
+
+if (failed === 0) {
+  console.log('\n🎉 所有测试通过！Cangming 安装成功。');
+  console.log('\n下一步:');
+  console.log('1. 启动 Cangming: cangming');
+  console.log('2. 查看可用角色: AGENTS.md 中包含所有角色索引');
+  console.log('3. 执行团队命令: /team-intake, /team-plan 等');
+  process.exit(0);
+} else {
+  console.log('\n⚠️  部分测试失败，请检查安装。');
+  process.exit(1);
+}

package/skills/goframe-v2/examples/practices/quick-demo/manifest/config/config.yaml

@@ -1,15 +1,15 @@
-# https://goframe.org/docs/web/server-config-file-template
-server:
-  address:     ":8000"
-  openapiPath: "/api.json"
-  swaggerPath: "/swagger"
-
-# https://goframe.org/docs/core/glog-config
-logger:
-  level : "all"
-  stdout: true
-
-# https://goframe.org/docs/core/gdb-config-file
-database:
-  default:
+# https://goframe.org/docs/web/server-config-file-template
+server:
+  address:     ":8000"
+  openapiPath: "/api.json"
+  swaggerPath: "/swagger"
+
+# https://goframe.org/docs/core/glog-config
+logger:
+  level : "all"
+  stdout: true
+
+# https://goframe.org/docs/core/gdb-config-file
+database:
+  default:
     link: "mysql:root:12345678@tcp(127.0.0.1:3306)/test"