agentdev 0.1.6 → 0.1.8

package/dist/create-feature-cli.cmd

@@ -0,0 +1,2 @@
+@echo off
+node "%~dp0\create-feature-cli.js" %*

package/dist/create-feature-cli.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+
+// src/create.ts
+import { mkdirSync, writeFileSync, existsSync as fsExistsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+async function createFeature(featureName2) {
+  const packageName = featureName2.startsWith("@agentdev/") ? featureName2 : `@agentdev/${featureName2}`;
+  const featureClass = toPascalCase(featureName2.replace("@agentdev/", ""));
+  const featureSlug = toKebabCase(featureName2.replace("@agentdev/", ""));
+  const targetDir = join(process.cwd(), featureSlug);
+  if (existsSync(targetDir)) {
+    throw new Error(`Directory already exists: ${targetDir}`);
+  }
+  console.log(`Creating AgentDev Feature: ${packageName}`);
+  console.log(`Target directory: ${targetDir}`);
+  mkdirSync(join(targetDir, "src"), { recursive: true });
+  mkdirSync(join(targetDir, "src", "templates"), { recursive: true });
+  mkdirSync(join(targetDir, "scripts"), { recursive: true });
+  generatePackageJson(targetDir, packageName, featureSlug);
+  generateTsConfig(targetDir);
+  generateCopyAssetsScript(targetDir);
+  generateMinimalFeatureClass(targetDir, featureClass);
+  generateMinimalReadme(targetDir, packageName, featureSlug);
+  console.log("\n\u2705 Feature package created successfully!");
+  console.log("\nNext steps:");
+  console.log(`  cd ${featureSlug}`);
+  console.log(`  npm install`);
+  console.log(`  # Edit src/index.ts to implement your feature`);
+  console.log(`  npm run build`);
+}
+function generatePackageJson(targetDir, packageName, featureSlug) {
+  const packageJson = {
+    name: packageName,
+    version: "0.1.0",
+    description: `${featureSlug} feature for AgentDev`,
+    type: "module",
+    main: "dist/index.js",
+    types: "dist/index.d.ts",
+    files: ["dist", "README.md"],
+    scripts: {
+      build: "tsup && npm run copy-assets",
+      dev: "tsup --watch",
+      "copy-assets": "node scripts/copy-assets.mjs",
+      prepublishOnly: "npm run build"
+    },
+    tsup: {
+      entry: ["src/index.ts", "src/templates/*.render.ts"],
+      format: "esm",
+      dts: true,
+      clean: true,
+      sourcemap: true
+    },
+    peerDependencies: {
+      agentdev: ">=0.1.0"
+    },
+    devDependencies: {
+      "@types/node": "^20.11.0",
+      tsup: "^8.3.5",
+      typescript: "^5.3.3",
+      agentdev: "latest"
+    },
+    keywords: ["agentdev", "feature", featureSlug],
+    license: "MIT"
+  };
+  writeFileSync(join(targetDir, "package.json"), JSON.stringify(packageJson, null, 2));
+}
+function generateTsConfig(targetDir) {
+  const tsConfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ES2022",
+      moduleResolution: "bundler",
+      outDir: "./dist",
+      rootDir: "./src",
+      declaration: true,
+      sourceMap: true,
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      resolveJsonModule: true,
+      allowSyntheticDefaultImports: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+  writeFileSync(join(targetDir, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+}
+function generateMinimalFeatureClass(targetDir, featureClass) {
+  const className = toCamelCase(featureClass);
+  const content = `/**
+ * ${featureClass} Feature
+ */
+
+import { fileURLToPath } from 'url';
+import type {
+  AgentFeature,
+  FeatureInitContext,
+  PackageInfo,
+} from 'agentdev';
+import type { Tool } from 'agentdev';
+import { getPackageInfoFromSource } from 'agentdev';
+
+export interface ${featureClass}Config {
+  /** \u914D\u7F6E\u9009\u9879 */
+  enabled?: boolean;
+}
+
+export class ${featureClass} implements AgentFeature {
+  readonly name = '${className}';
+  readonly dependencies: string[] = [];
+  readonly source = fileURLToPath(import.meta.url).replace(/\\\\/g, '/');
+  readonly description = '${featureClass} feature';
+
+  private config: ${featureClass}Config;
+  private _packageInfo: PackageInfo | null = null;
+
+  constructor(config: ${featureClass}Config = {}) {
+    this.config = {
+      enabled: config.enabled ?? true,
+    };
+  }
+
+  /**
+   * \u83B7\u53D6\u5305\u4FE1\u606F
+   */
+  getPackageInfo(): PackageInfo | null {
+    if (!this._packageInfo) {
+      this._packageInfo = getPackageInfoFromSource(this.source);
+    }
+    return this._packageInfo;
+  }
+
+  /**
+   * \u83B7\u53D6\u6A21\u677F\u540D\u79F0\u5217\u8868
+   */
+  getTemplateNames(): string[] {
+    return [];
+  }
+
+  /**
+   * \u83B7\u53D6\u5DE5\u5177\u5217\u8868
+   */
+  getTools(): Tool[] {
+    return [];
+  }
+
+  /**
+   * \u5F02\u6B65\u83B7\u53D6\u5DE5\u5177\u5217\u8868
+   */
+  async getAsyncTools(_ctx: FeatureInitContext): Promise<Tool[]> {
+    return [];
+  }
+
+  /**
+   * \u521D\u59CB\u5316
+   */
+  async onInitiate(_ctx: FeatureInitContext): Promise<void> {
+    // TODO: Feature \u521D\u59CB\u5316\u903B\u8F91
+  }
+
+  /**
+   * \u6E05\u7406\u8D44\u6E90
+   */
+  async onDestroy(): Promise<void> {
+    // TODO: Feature \u6E05\u7406\u903B\u8F91
+  }
+}
+`;
+  writeFileSync(join(targetDir, "src", "index.ts"), content);
+}
+function generateMinimalReadme(targetDir, packageName, featureSlug) {
+  const content = `# ${packageName}
+
+${featureSlug} feature for AgentDev.
+
+## Installation
+
+\`\`\`bash
+npm install ${packageName}
+\`\`\`
+
+## Usage
+
+\`\`\`typescript
+import { Agent } from 'agentdev';
+import { ${toPascalCase(featureSlug)} } from '${packageName}';
+
+const agent = new Agent().use(new ${toPascalCase(featureSlug)}());
+\`\`\`
+
+## Development
+
+\`\`\`bash
+npm install
+npm run build    # \u6216 npm run dev \u76D1\u542C\u6A21\u5F0F
+\`\`\`
+
+## License
+
+MIT
+`;
+  writeFileSync(join(targetDir, "README.md"), content);
+}
+function generateCopyAssetsScript(targetDir) {
+  const content = `#!/usr/bin/env node
+/**
+ * Copy non-TypeScript assets to dist directory
+ * This script automatically copies files like .py, .mp3, .json, etc.
+ */
+
+import { copyFileSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+const srcDir = join(rootDir, 'src');
+const distDir = join(rootDir, 'dist');
+
+// Extensions to copy (non-TypeScript files)
+const ASSET_EXTENSIONS = new Set([
+  '.mp3', '.wav', '.ogg', '.flac',  // Audio
+  '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico',  // Images
+  '.json',  // Config files
+  '.py', '.sh', '.bash', '.zsh',  // Scripts
+  '.txt', '.md', '.rst',  // Docs
+  '.yml', '.yaml', '.toml', '.ini',  // Config
+  '.sql', '.graphql', '.gql',  // Data
+  '.html', '.css', '.scss', '.less',  // Styles
+  '.wasm', '.bin',  // Binary
+]);
+
+function isAssetFile(filename) {
+  const idx = filename.lastIndexOf('.');
+  return idx >= 0 && ASSET_EXTENSIONS.has(filename.slice(idx).toLowerCase());
+}
+
+function copyDirectory(src, dest) {
+  const entries = readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else if (entry.isFile() && isAssetFile(entry.name)) {
+      mkdirSync(dirname(destPath), { recursive: true });
+      copyFileSync(srcPath, destPath);
+      console.log(\`Copied: \${relative(rootDir, srcPath)}\`);
+    }
+  }
+}
+
+// Copy assets from src to dist
+copyDirectory(srcDir, distDir);
+`;
+  writeFileSync(join(targetDir, "scripts", "copy-assets.mjs"), content);
+}
+function toPascalCase(str) {
+  return str.replace(/(?:^|-)([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toKebabCase(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function existsSync(path) {
+  try {
+    return !!fsExistsSync(path);
+  } catch {
+    return false;
+  }
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+if (args.length === 0) {
+  console.error("Usage: create-agentdev-feature <feature-name>");
+  console.error("Example: create-agentdev-feature my-feature");
+  process.exit(1);
+}
+var featureName = args[0];
+createFeature(featureName).catch((error) => {
+  console.error(`Error creating feature: ${error.message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "agentdev",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "A lightweight, decoupled AI agent framework with built-in debugger",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
     "agentdev-viewer": "dist/cli/viewer.cmd",
-    "agentdev-server": "dist/cli/server.cmd"
+    "agentdev-server": "dist/cli/server.cmd",
+    "agentdev-create-feature": "dist/create-feature-cli.cmd"
   },
   "files": [
     "dist",
@@ -18,7 +19,7 @@
     "build": "tsup && node scripts/generate-bin-cmds.mjs",
     "dev": "tsup --watch",
     "prepublishOnly": "npm run build",
-    "create-feature": "node packages/create-feature/dist/cli.js",
+    "create-feature": "node dist/create-feature-cli.js",
     "copy-example": "node scripts/copy-example-feature.mjs",
     "server": "node dist/cli/server.js"
   },