skill-distill 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,631 @@
+import { z } from 'zod';
+
+interface Message {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: string;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+}
+interface ToolCall {
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ToolResult {
+    name: string;
+    output: string;
+    success: boolean;
+}
+interface Session {
+    id: string;
+    projectPath: string;
+    messages: Message[];
+    startTime: string;
+    endTime?: string;
+    metadata?: Record<string, unknown>;
+}
+
+interface SkillMetadata {
+    name: string;
+    description: string;
+    version: string;
+    license?: string;
+}
+interface SkillStep {
+    title: string;
+    description: string;
+    substeps?: string[];
+}
+interface SkillParameter {
+    name: string;
+    type: 'string' | 'boolean' | 'number';
+    default?: unknown;
+    description: string;
+    required: boolean;
+}
+interface Skill {
+    metadata: SkillMetadata;
+    overview: string;
+    triggers: string[];
+    prerequisites: string[];
+    steps: SkillStep[];
+    parameters: SkillParameter[];
+    errorHandling: Record<string, string>;
+    examples: string[];
+    notes?: string[];
+    references?: string[];
+}
+
+interface Config {
+    defaultPlatform: 'claude' | 'codex' | 'cursor';
+    apiKey?: string;
+    outputDir: string;
+    autoInstall: boolean;
+    sessionSources: {
+        claude?: string;
+        codex?: string;
+        cursor?: string;
+    };
+}
+interface DistillOptions {
+    sessionId?: string;
+    last?: boolean;
+    prompts?: string[];
+    format?: 'claude' | 'codex' | 'cursor' | 'all';
+    outputDir?: string;
+    install?: boolean;
+    interactive?: boolean;
+}
+
+declare const logger: {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    step: (msg: string) => void;
+};
+
+declare function expandHome(path: string): string;
+declare function ensureDir(path: string): Promise<void>;
+declare function fileExists(path: string): Promise<boolean>;
+declare function readJson<T>(path: string): Promise<T>;
+declare function writeJson(path: string, data: unknown): Promise<void>;
+
+declare const SessionIdSchema: z.ZodString;
+declare const PlatformSchema: z.ZodEnum<["claude", "codex", "cursor"]>;
+declare const DistillOptionsSchema: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+    last: z.ZodOptional<z.ZodBoolean>;
+    prompts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    format: z.ZodOptional<z.ZodEnum<["claude", "codex", "cursor", "all"]>>;
+    outputDir: z.ZodOptional<z.ZodString>;
+    install: z.ZodOptional<z.ZodBoolean>;
+    interactive: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    sessionId?: string | undefined;
+    last?: boolean | undefined;
+    prompts?: string[] | undefined;
+    format?: "claude" | "codex" | "cursor" | "all" | undefined;
+    outputDir?: string | undefined;
+    install?: boolean | undefined;
+    interactive?: boolean | undefined;
+}, {
+    sessionId?: string | undefined;
+    last?: boolean | undefined;
+    prompts?: string[] | undefined;
+    format?: "claude" | "codex" | "cursor" | "all" | undefined;
+    outputDir?: string | undefined;
+    install?: boolean | undefined;
+    interactive?: boolean | undefined;
+}>;
+declare function validateSessionId(id: unknown): string;
+declare function validatePlatform(platform: unknown): 'claude' | 'codex' | 'cursor';
+
+interface SessionInfo {
+    id: string;
+    projectPath: string;
+    startTime: string;
+    endTime?: string;
+    messageCount: number;
+    summary?: string;
+}
+interface SessionLoaderOptions {
+    basePath?: string;
+    projectPath?: string;
+}
+declare abstract class SessionLoader {
+    protected basePath: string;
+    protected projectPath?: string;
+    constructor(options?: SessionLoaderOptions);
+    abstract getDefaultBasePath(): string;
+    abstract listSessions(): Promise<SessionInfo[]>;
+    abstract getSession(id: string): Promise<Session>;
+    getLatestSession(): Promise<Session>;
+    searchSessions(query: string): Promise<SessionInfo[]>;
+}
+
+declare class ClaudeSessionLoader extends SessionLoader {
+    constructor(options?: SessionLoaderOptions);
+    getDefaultBasePath(): string;
+    listSessions(): Promise<SessionInfo[]>;
+    getSession(id: string): Promise<Session>;
+    private readSessionFile;
+    private transformSession;
+    private transformMessage;
+    private extractSummary;
+}
+
+declare class CodexSessionLoader extends SessionLoader {
+    getDefaultBasePath(): string;
+    listSessions(): Promise<SessionInfo[]>;
+    getSession(_id: string): Promise<Session>;
+}
+
+declare class CursorSessionLoader extends SessionLoader {
+    getDefaultBasePath(): string;
+    listSessions(): Promise<SessionInfo[]>;
+    getSession(_id: string): Promise<Session>;
+}
+
+type Platform = 'claude' | 'codex' | 'cursor';
+declare function createSessionLoader(platform: Platform, options?: SessionLoaderOptions): SessionLoader;
+
+declare const IntentSchema: z.ZodObject<{
+    goal: z.ZodString;
+    problem: z.ZodString;
+    outcome: z.ZodString;
+    triggers: z.ZodArray<z.ZodString, "many">;
+    category: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    goal: string;
+    problem: string;
+    outcome: string;
+    triggers: string[];
+    category: string;
+}, {
+    goal: string;
+    problem: string;
+    outcome: string;
+    triggers: string[];
+    category: string;
+}>;
+declare const StepSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    substeps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isKeyStep: z.ZodBoolean;
+    toolsUsed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description: string;
+    isKeyStep: boolean;
+    substeps?: string[] | undefined;
+    toolsUsed?: string[] | undefined;
+}, {
+    title: string;
+    description: string;
+    isKeyStep: boolean;
+    substeps?: string[] | undefined;
+    toolsUsed?: string[] | undefined;
+}>;
+declare const StepsResultSchema: z.ZodObject<{
+    steps: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodString;
+        substeps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        isKeyStep: z.ZodBoolean;
+        toolsUsed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        description: string;
+        isKeyStep: boolean;
+        substeps?: string[] | undefined;
+        toolsUsed?: string[] | undefined;
+    }, {
+        title: string;
+        description: string;
+        isKeyStep: boolean;
+        substeps?: string[] | undefined;
+        toolsUsed?: string[] | undefined;
+    }>, "many">;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["string", "boolean", "number"]>;
+        description: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean";
+        description: string;
+        name: string;
+        defaultValue?: unknown;
+    }, {
+        type: "string" | "number" | "boolean";
+        description: string;
+        name: string;
+        defaultValue?: unknown;
+    }>, "many">;
+    prerequisites: z.ZodArray<z.ZodString, "many">;
+    errorHandling: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    steps: {
+        title: string;
+        description: string;
+        isKeyStep: boolean;
+        substeps?: string[] | undefined;
+        toolsUsed?: string[] | undefined;
+    }[];
+    parameters: {
+        type: "string" | "number" | "boolean";
+        description: string;
+        name: string;
+        defaultValue?: unknown;
+    }[];
+    prerequisites: string[];
+    errorHandling: Record<string, string>;
+}, {
+    steps: {
+        title: string;
+        description: string;
+        isKeyStep: boolean;
+        substeps?: string[] | undefined;
+        toolsUsed?: string[] | undefined;
+    }[];
+    parameters: {
+        type: "string" | "number" | "boolean";
+        description: string;
+        name: string;
+        defaultValue?: unknown;
+    }[];
+    prerequisites: string[];
+    errorHandling: Record<string, string>;
+}>;
+type Intent = z.infer<typeof IntentSchema>;
+type DistilledStep = z.infer<typeof StepSchema>;
+type StepsResult = z.infer<typeof StepsResultSchema>;
+interface LLMEngineOptions {
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+}
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+declare class LLMEngine {
+    private client;
+    private model;
+    private maxTokens;
+    private totalUsage;
+    constructor(options?: LLMEngineOptions);
+    extractIntent(session: Session): Promise<Intent>;
+    distillSteps(session: Session, intent: Intent, userPrompts?: string[]): Promise<StepsResult>;
+    enhanceQuality(skill: Partial<Skill>): Promise<Skill>;
+    generateDescription(intent: Intent): Promise<string>;
+    chat(prompt: string, system?: string): Promise<string>;
+    getTokenUsage(): TokenUsage;
+    private formatConversation;
+    private parseJson;
+    private withRetry;
+    private sleep;
+}
+
+interface DistillerOptions {
+    userPrompts?: string[];
+    skipFailedFilter?: boolean;
+    verbose?: boolean;
+}
+interface DistillResult {
+    skill: Skill;
+    metadata: {
+        sessionId: string;
+        distilledAt: string;
+        tokenUsage: {
+            input: number;
+            output: number;
+        };
+        stepsFiltered: number;
+    };
+}
+declare class Distiller {
+    private llmEngine;
+    private preprocessor;
+    private failedFilter;
+    private parameterExtractor;
+    constructor(llmEngine?: LLMEngine);
+    distill(session: Session, options?: DistillerOptions): Promise<DistillResult>;
+    private convertParameters;
+    private assembleSkill;
+    private generateName;
+    private generateExamples;
+}
+
+interface ProcessedMessage extends Message {
+    turnIndex: number;
+    hasToolCalls: boolean;
+    hasCodeBlocks: boolean;
+    codeBlocks: string[];
+    sentiment: 'positive' | 'negative' | 'neutral';
+}
+interface PreprocessResult {
+    messages: ProcessedMessage[];
+    totalTurns: number;
+    toolCallCount: number;
+}
+declare class ConversationPreprocessor {
+    private positiveSignals;
+    private negativeSignals;
+    process(messages: Message[]): PreprocessResult;
+    private extractCodeBlocks;
+    private analyzeSentiment;
+}
+
+interface FilterResult {
+    messages: ProcessedMessage[];
+    removedCount: number;
+    removedTurns: number[];
+}
+declare class FailedAttemptFilter {
+    private failureIndicators;
+    filter(messages: ProcessedMessage[]): FilterResult;
+    private identifyFailedTurns;
+    private hasFailureSignal;
+}
+
+interface ExtractResult {
+    steps: SkillStep[];
+    parameters: SkillParameter[];
+}
+declare class ParameterExtractor {
+    private patterns;
+    extract(steps: DistilledStep[], existingParams: SkillParameter[]): ExtractResult;
+    private generateParamName;
+}
+
+type PromptType = 'focus' | 'constraint' | 'supplement' | 'style' | 'exclude';
+interface ClassifiedPrompt {
+    original: string;
+    type: PromptType;
+    keywords: string[];
+    target?: string;
+    action?: string;
+}
+interface PromptEffect {
+    stepWeights?: Map<string, number>;
+    additionalPrerequisites?: string[];
+    stepEnrichments?: Map<string, string[]>;
+    verbosityLevel?: 'minimal' | 'standard' | 'detailed';
+    excludePatterns?: string[];
+}
+
+interface PromptHandlerOptions {
+    language?: 'en' | 'zh';
+}
+declare class PromptHandler {
+    private classifier;
+    private fuser;
+    constructor(options?: PromptHandlerOptions);
+    process(prompts: string[]): PromptEffect;
+    classify(prompt: string): ClassifiedPrompt;
+    toPromptText(prompts: string[]): string;
+}
+
+declare class PromptClassifier {
+    private language;
+    private patterns;
+    constructor(language?: 'en' | 'zh');
+    classify(prompt: string): ClassifiedPrompt;
+    private extractTarget;
+}
+
+declare class PromptFuser {
+    fuse(prompts: ClassifiedPrompt[]): PromptEffect;
+    private applyFocus;
+    private applyConstraint;
+    private applySupplement;
+    private applyStyle;
+    private applyExclude;
+}
+
+interface CollectedPrompts {
+    prompts: string[];
+    confirmed: boolean;
+}
+declare function collectPromptsInteractively(): Promise<CollectedPrompts>;
+declare function selectPromptsFromSuggestions(suggestions: string[]): Promise<string[]>;
+
+interface ValidationError {
+    field: string;
+    message: string;
+    severity: 'error' | 'warning';
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+}
+declare class TemplateValidator {
+    validate(content: string, skill: Skill): ValidationResult;
+    private validateFrontmatter;
+    private validateRequiredSections;
+    private validateWritingStyle;
+    private validateLength;
+}
+
+interface GenerateOptions {
+    outputDir: string;
+    overwrite?: boolean;
+    includeReferences?: boolean;
+    includeExamples?: boolean;
+}
+interface GenerateResult {
+    skillPath: string;
+    files: string[];
+    validation: ValidationResult;
+}
+declare class SkillGenerator {
+    private frontmatterBuilder;
+    private markdownRenderer;
+    private directoryBuilder;
+    private validator;
+    constructor();
+    generate(skill: Skill, options: GenerateOptions): Promise<GenerateResult>;
+    renderSkill(skill: Skill): string;
+    private generateReferences;
+    private toKebabCase;
+    private exists;
+}
+
+declare class FrontmatterBuilder {
+    build(metadata: SkillMetadata): string;
+    validateDescription(description: string): boolean;
+}
+
+declare class MarkdownRenderer {
+    renderTitle(name: string): string;
+    renderOverview(overview: string): string;
+    renderTriggers(triggers: string[]): string;
+    renderPrerequisites(prerequisites: string[]): string;
+    renderSteps(steps: SkillStep[]): string;
+    renderParameters(parameters: SkillParameter[]): string;
+    renderErrorHandling(errorHandling: Record<string, string>): string;
+    renderExamples(examples: string[]): string;
+    renderReferences(references: string[]): string;
+    renderNotes(notes: string[]): string;
+}
+
+interface DirectoryOptions {
+    includeReferences: boolean;
+    includeExamples: boolean;
+    includeScripts: boolean;
+}
+declare class DirectoryBuilder {
+    create(basePath: string, options?: Partial<DirectoryOptions>): Promise<void>;
+    listStructure(basePath: string): Promise<string[]>;
+}
+
+interface ConvertOptions {
+    includeMetadata?: boolean;
+    includeExamples?: boolean;
+    verbose?: boolean;
+}
+declare class ClaudeFormatter {
+    format(skill: Skill, options?: ConvertOptions): string;
+    private formatFrontmatter;
+    private formatTriggers;
+    private formatPrerequisites;
+    private formatSteps;
+    private formatParameters;
+    private formatErrorHandling;
+    private formatExamples;
+    private formatNotes;
+}
+
+type OutputFormat = 'claude' | 'codex' | 'cursor';
+
+declare class FormatConverter {
+    private claudeFormatter;
+    private codexFormatter;
+    private cursorFormatter;
+    constructor();
+    convert(skill: Skill, format: OutputFormat, options?: ConvertOptions): string;
+    convertAll(skill: Skill, options?: ConvertOptions): Map<OutputFormat, string>;
+    toClaudeFormat(skill: Skill, options?: ConvertOptions): string;
+    toCodexFormat(skill: Skill, options?: ConvertOptions): string;
+    toCursorFormat(skill: Skill, options?: ConvertOptions): string;
+}
+
+declare class CodexFormatter {
+    format(skill: Skill, _options?: ConvertOptions): string;
+    private formatFrontmatter;
+    private toKebabCase;
+}
+
+declare class CursorFormatter {
+    format(skill: Skill, _options?: ConvertOptions): string;
+}
+
+interface FormatValidation {
+    valid: boolean;
+    format: string;
+    errors: string[];
+    warnings: string[];
+}
+declare class FormatValidator {
+    validateClaude(content: string): FormatValidation;
+    validateCodex(content: string): FormatValidation;
+    validateCursor(content: string): FormatValidation;
+}
+
+interface InstallOptions {
+    overwrite?: boolean;
+    backup?: boolean;
+    verify?: boolean;
+}
+interface InstallResult {
+    success: boolean;
+    path: string;
+    message: string;
+    backupPath?: string;
+}
+interface InstalledSkill {
+    name: string;
+    path: string;
+    version: string;
+    installedAt: string;
+}
+declare abstract class AgentInstaller {
+    protected basePath: string;
+    constructor(basePath?: string);
+    abstract getDefaultBasePath(): string;
+    abstract getPlatformName(): string;
+    abstract install(skill: Skill, options?: InstallOptions): Promise<InstallResult>;
+    abstract uninstall(skillName: string): Promise<void>;
+    abstract list(): Promise<InstalledSkill[]>;
+    verify(skillName: string): Promise<boolean>;
+}
+
+declare class ClaudeCodeInstaller extends AgentInstaller {
+    private generator;
+    constructor(basePath?: string);
+    getDefaultBasePath(): string;
+    getPlatformName(): string;
+    install(skill: Skill, options?: InstallOptions): Promise<InstallResult>;
+    uninstall(skillName: string): Promise<void>;
+    list(): Promise<InstalledSkill[]>;
+    private verifyInstallation;
+    private parseMetadata;
+    private toKebabCase;
+}
+
+declare class CodexInstaller extends AgentInstaller {
+    private converter;
+    constructor(basePath?: string);
+    getDefaultBasePath(): string;
+    getPlatformName(): string;
+    install(skill: Skill, options?: InstallOptions): Promise<InstallResult>;
+    uninstall(skillName: string): Promise<void>;
+    list(): Promise<InstalledSkill[]>;
+    private toKebabCase;
+}
+
+declare class CursorInstaller extends AgentInstaller {
+    private converter;
+    private projectPath;
+    constructor(projectPath: string);
+    getDefaultBasePath(): string;
+    getPlatformName(): string;
+    install(skill: Skill, options?: InstallOptions): Promise<InstallResult>;
+    uninstall(_skillName: string): Promise<void>;
+    list(): Promise<InstalledSkill[]>;
+}
+
+type InstallerPlatform = 'claude' | 'codex' | 'cursor';
+interface InstallerOptions {
+    basePath?: string;
+    projectPath?: string;
+}
+declare function createInstaller(platform: InstallerPlatform, options?: InstallerOptions): AgentInstaller;
+
+declare const VERSION = "0.1.0";
+
+export { AgentInstaller, type ClassifiedPrompt, ClaudeCodeInstaller, ClaudeFormatter, ClaudeSessionLoader, CodexFormatter, CodexInstaller, CodexSessionLoader, type CollectedPrompts, type Config, ConversationPreprocessor, type ConvertOptions, CursorFormatter, CursorInstaller, CursorSessionLoader, DirectoryBuilder, type DirectoryOptions, type DistillOptions, DistillOptionsSchema, type DistillResult, type DistilledStep, Distiller, type DistillerOptions, FailedAttemptFilter, type FilterResult, FormatConverter, type FormatValidation, FormatValidator, FrontmatterBuilder, type GenerateOptions, type GenerateResult, type InstallOptions, type InstallResult, type InstalledSkill, type InstallerOptions, type InstallerPlatform, type Intent, LLMEngine, MarkdownRenderer, type Message, type OutputFormat, ParameterExtractor, type Platform, PlatformSchema, type PreprocessResult, type ProcessedMessage, PromptClassifier, type PromptEffect, PromptFuser, PromptHandler, type PromptHandlerOptions, type PromptType, type Session, SessionIdSchema, type SessionInfo, SessionLoader, type SessionLoaderOptions, type Skill, SkillGenerator, type SkillMetadata, type SkillParameter, type SkillStep, type StepsResult, TemplateValidator, type ToolCall, type ToolResult, VERSION, type ValidationError, type ValidationResult, collectPromptsInteractively, createInstaller, createSessionLoader, ensureDir, expandHome, fileExists, logger, readJson, selectPromptsFromSuggestions, validatePlatform, validateSessionId, writeJson };