@cfxdevkit/create

Project scaffolder (npm create @cfxdevkit).

Install

pnpm


pnpm add @cfxdevkit/create

npm


npm install @cfxdevkit/create

yarn


yarn add @cfxdevkit/create

Scope: Project generator. npx @cfxdevkit/create <template>.

Responsibilities

Template discovery from ../../templates/
Variable substitution using {{ variable }} syntax
Post-install setup (runs pnpm install, git init, and creates .env if present in template)
Optional integrations (wallet, MCP, devcontainer) via template-specific hooks

Usage


npx @cfxdevkit/create <template-name> [project-dir]

If project-dir is omitted, defaults to <template-name>.

API Reference

`.`

Symbol	Description
`scaffoldProject`	Main entry point. Accepts `projectName` and `options` (`name`, `description?`). Writes files to disk and runs post-install hooks.
`parseArgs`	Parses CLI arguments into `{ name, description? }`.
`validateName`	Validates project name against npm naming rules (e.g., no uppercase, no special chars except `-` and `_`).
`getTemplate`	Fetches a template definition by name from `../../templates/`. Returns `undefined` if not found.
`listTemplates`	Lists all available templates in `../../templates/`.
`getTemplateFiles`	Returns files to be generated for a given template and optional target (e.g., `"client"`, `"server"`).
`renderFile`	Renders a template file with variable substitution using `{{ key }}` syntax.
`TemplateDefinition`, `TemplateFile`, `TemplateTarget`	Type definitions for templates and their structure.
`__packageName`	Internal constant: `"@cfxdevkit/create"`.

`./templates`

Re-exports core template-related types and utilities:

Symbol	Description
`listTemplates`	Returns `TemplateDefinition[]`.
`getTemplate(name)`	Returns `TemplateDefinition
`renderFile(content, values)`	Substitutes `{{ key }}` placeholders in `content` with `values`.
`getTemplateFiles(template, target?)`	Returns `TemplateFile[]` for the given template and optional target (e.g., `"client"`, `"server"`).
`TemplateDefinition`, `TemplateFile`, `TemplateTarget`	Type definitions for templates and their structure.

Template Format

Templates are defined in ../../templates/ as directories containing:

template.json: metadata (name, description, files, target?)
files/: template files with {{ variable }} placeholders
Optional hooks/: scripts executed post-scaffold (e.g., setup-wallet.sh, init-mcp.sh)

Example


import { scaffoldProject } from '@cfxdevkit/create';
 
await scaffoldProject('basic', {
  name: 'my-project',
  description: 'My generated project',
});

Tier

Tier 1 — platform — May import Tier 0 framework packages.

API Reference

See API.md for the full public surface.

API Reference

`.`

Usage


import { parseArgs, scaffoldProject, validateName } from '@cfxdevkit/create';
 
const args = parseArgs();
if (validateName(args.name)) {
  scaffoldProject(args.name, {
    name: args.name,
    description: 'Generated project'
  });
}


// The name of the package
export declare const __packageName: "@cfxdevkit/create";
// Parses command-line arguments passed to the CLI
export declare function parseArgs(): { name: string; description?: string };
// Scaffolds a new project using a template, writing files to disk
export declare function scaffoldProject(projectName: string, options: { name: string; description?: string }): Promise<void>;
// Defines the structure of a project template
export interface TemplateDefinition {
  name: string;
  description: string;
  files: TemplateFile[];
  target?: TemplateTarget;
}
// Defines a single file within a template, including its name and content
export interface TemplateFile {
  name: string;
  content: string;
}
// Defines the target context (e.g., root, src) for where template files should be placed
export type TemplateTarget = 'root' | 'src' | string;
// Retrieves a template by its registered name
export declare function getTemplate(name: string): TemplateDefinition | undefined;
// Retrieves the resolved file list for a given template, optionally scoped to a target context
export declare function getTemplateFiles(template: TemplateDefinition, target?: TemplateTarget): TemplateFile[];
// Lists all available registered templates
export declare function listTemplates(): TemplateDefinition[];
// Renders template content (e.g., with Mustache-style placeholders) using provided values
export declare function renderFile(content: string, values: Record<string, string>): string;
// Validates whether a given project name conforms to naming conventions (e.g., npm package name rules)
export declare function validateName(name: string): boolean;

`./templates`

Usage


// Example usage of `TemplateDefinition`
const templateDefinition = {
  name: 'my-template',
  description: 'A sample template',
  files: [
    { name: 'index.html', content: '<h1>Hello, World!</h1>' },
    { name: 'style.css', content: 'body { background-color: #f0f0f0; }' }
  ]
};
 
// Example usage of `getTemplateFiles`
const files = getTemplateFiles(templateDefinition, 'src');
console.log(files);
 
// Example usage of `listTemplates`
const templates = listTemplates();
console.log(templates);
 
// Example usage of `getTemplate`
const template = getTemplate('my-template');
console.log(template);
 
// Example usage of `renderFile`
const content = renderFile('Hello {{name}}!', { name: 'John Doe' });
console.log(content); // => "Hello John Doe!"


// Defines the structure of a project template
export interface TemplateDefinition {
  name: string;
  description: string;
  files: TemplateFile[];
  target?: TemplateTarget;
}
// Defines a single file within a template
export interface TemplateFile {
  name: string;
  content: string;
}
// Defines the target context for template files
export type TemplateTarget = 'root' | 'src' | string;
// Lists all available templates registered in the system
export declare function listTemplates(): TemplateDefinition[];
// Retrieves a template by its registered name, returning `undefined` if not found
export declare function getTemplate(name: string): TemplateDefinition | undefined;
// Renders template content (e.g., with placeholders like `{{name}}`) using provided key-value pairs
export declare function renderFile(content: string, values: Record<string, string>): string;
// Resolves and returns the list of files for a given template, optionally filtered by target context
export declare function getTemplateFiles(template: TemplateDefinition, target?: TemplateTarget): TemplateFile[];