tools-cc 1.0.7 → 1.0.9

package/src/core/template.ts

@@ -0,0 +1,91 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { TemplateConfig, ProjectConfig } from '../types';
+
+/**
+ * 保存项目配置为模板
+ */
+export async function saveTemplate(
+  name: string,
+  sourceProject: string,
+  config: ProjectConfig,
+  templatesDir: string
+): Promise<TemplateConfig> {
+  if (!name || !name.trim()) {
+    throw new Error('Template name is required');
+  }
+
+  await fs.ensureDir(templatesDir);
+
+  const template: TemplateConfig = {
+    version: '1.0',
+    name,
+    sourceProject,
+    savedAt: new Date().toISOString(),
+    config
+  };
+
+  const templatePath = path.join(templatesDir, `${name}.json`);
+  await fs.writeJson(templatePath, template, { spaces: 2 });
+
+  return template;
+}
+
+/**
+ * 列出所有模板
+ */
+export async function listTemplates(templatesDir: string): Promise<TemplateConfig[]> {
+  if (!(await fs.pathExists(templatesDir))) {
+    return [];
+  }
+
+  const files = await fs.readdir(templatesDir);
+  const templates: TemplateConfig[] = [];
+
+  for (const file of files) {
+    if (file.endsWith('.json')) {
+      try {
+        const template = await fs.readJson(path.join(templatesDir, file));
+        if (template.version && template.name && template.config) {
+          templates.push(template);
+        }
+      } catch {
+        // Skip invalid files
+      }
+    }
+  }
+
+  return templates.sort((a, b) => b.savedAt.localeCompare(a.savedAt));
+}
+
+/**
+ * 获取指定模板
+ */
+export async function getTemplate(
+  name: string,
+  templatesDir: string
+): Promise<TemplateConfig | null> {
+  const templatePath = path.join(templatesDir, `${name}.json`);
+
+  if (!(await fs.pathExists(templatePath))) {
+    return null;
+  }
+
+  return await fs.readJson(templatePath);
+}
+
+/**
+ * 删除模板
+ */
+export async function removeTemplate(
+  name: string,
+  templatesDir: string
+): Promise<void> {
+  const templatePath = path.join(templatesDir, `${name}.json`);
+
+  if (!(await fs.pathExists(templatePath))) {
+    throw new Error(`Template not found: ${name}`);
+  }
+
+  await fs.remove(templatePath);
+}

package/src/index.ts

@@ -3,9 +3,10 @@
 import { Command } from 'commander';
 import { handleConfigSet, handleConfigGet, handleConfigList } from './commands/config';
 import { handleSourceAdd, handleSourceList, handleSourceRemove, handleSourceUpdate, handleSourceScan } from './commands/source';
-import { handleUse, handleList, handleRemove, handleStatus, handleProjectUpdate } from './commands/use';
-import { handleExport } from './commands/export';
-import { showHelp } from './commands/help';
+import { handleUse, handleList, handleRemove, handleStatus, handleProjectUpdate } from './commands/use';
+import { handleExport } from './commands/export';
+import { handleTemplateSave, handleTemplateList, handleTemplateRemove, handleTemplateUse } from './commands/template';
+import { showHelp } from './commands/help';
 
 const program = new Command();
 
@@ -89,16 +90,52 @@ configCmd
     await handleConfigList();
   });
 
+// Template commands
+const templateCmd = program
+  .command('template')
+  .description('Template management')
+  .alias('tpl');
+
+templateCmd
+  .command('save')
+  .description('Save current project config as template')
+  .option('-n, --name <name>', 'Template name (default: project directory name)')
+  .action(async (options) => {
+    await handleTemplateSave(options);
+  });
+
+templateCmd
+  .command('list')
+  .alias('ls')
+  .description('List all saved templates')
+  .action(async () => {
+    await handleTemplateList();
+  });
+
+templateCmd
+  .command('rm <name>')
+  .description('Remove a template')
+  .action(async (name: string) => {
+    await handleTemplateRemove(name);
+  });
+
+templateCmd
+  .command('use [name]')
+  .description('Apply a template to current project')
+  .action(async (name?: string) => {
+    await handleTemplateUse(name);
+  });
+
 // Project commands
 program
-  .command('use [sources...]')
-  .description('Use sources in current project')
-  .option('-p, --projects <tools...>', 'Tools to link (iflow, claude, codebuddy, opencode, codex)')
-  .option('-l, --ls', 'Interactive selection mode for single source')
-  .option('-c, --config <file>', 'Import from config file')
-  .action(async (sources: string[], options) => {
-    await handleUse(sources, options);
-  });
+  .command('use [sources...]')
+  .description('Use sources in current project')
+  .option('-p, --projects <tools...>', 'Tools to link (iflow, claude, codebuddy, opencode, codex)')
+  .option('-l, --ls', 'Interactive selection mode for single source')
+  .option('-c, --config <file>', 'Import from config file')
+  .action(async (sources: string[], options) => {
+    await handleUse(sources, options);
+  });
 
 program
   .command('list')

package/src/types/config.ts

@@ -10,12 +10,13 @@ export interface GlobalConfig {
 }
 
 /**
- * 源选择配置 - 指定从源中导入哪些 skills/commands/agents
+ * 源选择配置 - 指定从源中导入哪些 skills/commands/agents/rules
  */
 export interface SourceSelection {
   skills: string[];
   commands: string[];
   agents: string[];
+  rules: string[];
 }
 
 /**
@@ -43,7 +44,8 @@ export function isSourceSelection(value: unknown): value is SourceSelection {
   return (
     Array.isArray(obj.skills) &&
     Array.isArray(obj.commands) &&
-    Array.isArray(obj.agents)
+    Array.isArray(obj.agents) &&
+    Array.isArray(obj.rules)
   );
 }
 
@@ -61,7 +63,8 @@ export function normalizeProjectConfig(
       newSources[sourceName] = {
         skills: ['*'],
         commands: ['*'],
-        agents: ['*']
+        agents: ['*'],
+        rules: ['*']
       };
     }
     return { sources: newSources, links: config.links };
@@ -75,6 +78,7 @@ export interface Manifest {
   skills?: string[];
   commands?: string[];
   agents?: string[];
+  rules?: string[];
 }
 
 export interface ToolConfig {
@@ -99,4 +103,15 @@ export interface GlobalExportConfig {
   type: 'global';
   config: GlobalConfig;
   exportedAt: string;
+}
+
+/**
+ * 模板配置格式
+ */
+export interface TemplateConfig {
+  version: string;
+  name: string;
+  sourceProject: string;
+  savedAt: string;
+  config: ProjectConfig;
 }

package/src/utils/parsePath.ts

@@ -5,7 +5,7 @@ import { SourceSelection } from '../types/config';
  */
 export interface ParsedSourcePath {
   sourceName: string;
-  type?: 'skills' | 'commands' | 'agents';
+  type?: 'skills' | 'commands' | 'agents' | 'rules';
   itemName?: string;
 }
 
@@ -36,7 +36,7 @@ export function parseSourcePath(input: string): ParsedSourcePath {
   }
   
   // 检查第二部分是否为有效类型
-  const validTypes = ['skills', 'commands', 'agents'] as const;
+  const validTypes = ['skills', 'commands', 'agents', 'rules'] as const;
   const type = parts[1] as typeof validTypes[number];
   
   if (!validTypes.includes(type)) {
@@ -81,7 +81,8 @@ export function buildSelectionFromPaths(paths: string[]): Record<string, SourceS
       result[sourceName] = {
         skills: [],
         commands: [],
-        agents: []
+        agents: [],
+        rules: []
       };
     }
     
@@ -90,7 +91,8 @@ export function buildSelectionFromPaths(paths: string[]): Record<string, SourceS
       result[sourceName] = {
         skills: ['*'],
         commands: ['*'],
-        agents: ['*']
+        agents: ['*'],
+        rules: ['*']
       };
       continue;
     }

package/src/utils/path.ts

@@ -1,18 +1,23 @@
-import os from 'os';
-import path from 'path';
-
-export const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.tools-cc');
-export const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, 'config.json');
-
-export const DEFAULT_CONFIG = {
-  sourcesDir: path.join(GLOBAL_CONFIG_DIR, 'sources'),
-  sources: {}
-};
-
-export function getToolsccDir(projectDir: string): string {
-  return path.join(projectDir, '.toolscc');
-}
-
-export function getProjectConfigPath(projectDir: string): string {
-  return path.join(getToolsccDir(projectDir), 'config.json');
-}
+import os from 'os';
+import path from 'path';
+
+export const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.tools-cc');
+export const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, 'config.json');
+export const TEMPLATES_DIR = path.join(GLOBAL_CONFIG_DIR, 'templates');
+
+export const DEFAULT_CONFIG = {
+  sourcesDir: path.join(GLOBAL_CONFIG_DIR, 'sources'),
+  sources: {}
+};
+
+export function getTemplatePath(templateName: string): string {
+  return path.join(TEMPLATES_DIR, `${templateName}.json`);
+}
+
+export function getToolsccDir(projectDir: string): string {
+  return path.join(projectDir, '.toolscc');
+}
+
+export function getProjectConfigPath(projectDir: string): string {
+  return path.join(getToolsccDir(projectDir), 'config.json');
+}

package/tests/commands/export.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { handleExport } from '../../src/commands/export';
+import { initProject, useSource } from '../../src/core/project';
+import { GLOBAL_CONFIG_DIR } from '../../src/utils/path';
+
+describe('handleExport', () => {
+  const testProjectDir = path.join(__dirname, '../fixtures/test-export-cmd-project');
+  const testSourceDir = path.join(__dirname, '../fixtures/test-export-cmd-source');
+  const exportFilePath = path.join(__dirname, '../fixtures/test-export-cmd.json');
+  const globalExportPath = path.join(__dirname, '../fixtures/test-global-export-cmd.json');
+
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    // Create test source
+    await fs.ensureDir(path.join(testSourceDir, 'skills', 'test-skill'));
+    await fs.writeFile(path.join(testSourceDir, 'skills', 'test-skill', 'test.md'), '# test skill');
+
+    // Create project directory
+    await fs.ensureDir(testProjectDir);
+
+    // Spy on console.log
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(async () => {
+    await fs.remove(testProjectDir);
+    await fs.remove(testSourceDir);
+    await fs.remove(exportFilePath);
+    await fs.remove(globalExportPath);
+    consoleLogSpy.mockRestore();
+  });
+
+  it('should export project config to default path', async () => {
+    // Initialize project with a source
+    await initProject(testProjectDir);
+    await useSource('test-source', testSourceDir, testProjectDir);
+
+    // Change to project directory for the test
+    const originalCwd = process.cwd();
+    process.chdir(testProjectDir);
+
+    try {
+      await handleExport({});
+
+      // Check default export file was created
+      const defaultExportPath = path.join(testProjectDir, '.toolscc-export.json');
+      expect(await fs.pathExists(defaultExportPath)).toBe(true);
+
+      // Verify file content
+      const exported = await fs.readJson(defaultExportPath);
+      expect(exported.version).toBe('1.0');
+      expect(exported.type).toBe('project');
+
+      // Verify console output
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('✓ Project config exported to:')
+      );
+
+      // Cleanup
+      await fs.remove(defaultExportPath);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should export project config to custom path', async () => {
+    await initProject(testProjectDir);
+    await useSource('test-source', testSourceDir, testProjectDir);
+
+    const originalCwd = process.cwd();
+    process.chdir(testProjectDir);
+
+    try {
+      await handleExport({ output: exportFilePath });
+
+      expect(await fs.pathExists(exportFilePath)).toBe(true);
+
+      const exported = await fs.readJson(exportFilePath);
+      expect(exported.version).toBe('1.0');
+      expect(exported.type).toBe('project');
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should export global config with --global flag', async () => {
+    const originalCwd = process.cwd();
+    process.chdir(testProjectDir);
+
+    try {
+      await handleExport({ global: true, output: globalExportPath });
+
+      expect(await fs.pathExists(globalExportPath)).toBe(true);
+
+      const exported = await fs.readJson(globalExportPath);
+      expect(exported.version).toBe('1.0');
+      expect(exported.type).toBe('global');
+      expect(exported.config).toBeDefined();
+      expect(exported.config.sourcesDir).toBeDefined();
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should throw error when exporting non-initialized project', async () => {
+    const originalCwd = process.cwd();
+    process.chdir(testProjectDir);
+
+    try {
+      // Don't initialize project
+      await expect(handleExport({ output: exportFilePath }))
+        .rejects.toThrow();
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});