@nogataka/smart-edit 0.0.14

package/dist/interprompt/multilang_prompt.d.ts

@@ -0,0 +1,54 @@
+import { type ParameterizedTemplateInterface } from './jinja_template.js';
+export declare const DEFAULT_LANG_CODE = "default";
+export declare enum LanguageFallbackMode {
+    ANY = "any",
+    EXCEPTION = "exception",
+    USE_DEFAULT_LANG = "use_default_lang"
+}
+export declare class PromptTemplate implements ParameterizedTemplateInterface {
+    readonly name: string;
+    private readonly template;
+    constructor(name: string, templateString: string);
+    render(params: Record<string, unknown>): string;
+    getParameters(): string[];
+}
+export declare class PromptList {
+    readonly items: string[];
+    constructor(items: string[]);
+    toString(): string;
+}
+export declare class MultiLangPromptTemplate implements ParameterizedTemplateInterface {
+    private readonly container;
+    constructor(name: string);
+    get name(): string;
+    get length(): number;
+    addPromptTemplate(template: PromptTemplate, langCode: string, allowOverwrite: boolean): void;
+    hasItem(langCode: string): boolean;
+    getPromptTemplate(langCode: string, fallbackMode: LanguageFallbackMode): PromptTemplate;
+    getParameters(): string[];
+}
+export declare class MultiLangPromptList {
+    private readonly container;
+    constructor(name: string);
+    addPromptList(list: PromptList, langCode: string, allowOverwrite: boolean): void;
+    hasItem(langCode: string): boolean;
+    getPromptList(langCode: string, fallbackMode: LanguageFallbackMode): PromptList;
+}
+export declare class MultiLangPromptCollection {
+    private readonly promptTemplates;
+    private readonly promptLists;
+    private _fallbackMode;
+    constructor(promptsDir: string | string[], fallbackMode?: LanguageFallbackMode);
+    get fallbackMode(): LanguageFallbackMode;
+    set fallbackMode(mode: LanguageFallbackMode);
+    private loadFromDisk;
+    private addPromptTemplate;
+    private addPromptList;
+    getPromptTemplateNames(): string[];
+    getPromptListNames(): string[];
+    getPromptTemplate(name: string, langCode: string): PromptTemplate;
+    getPromptTemplateParameters(name: string): string[];
+    getPromptList(name: string, langCode: string): PromptList;
+    hasPromptTemplate(name: string, langCode: string): boolean;
+    renderPromptTemplate(name: string, params: Record<string, unknown>, langCode: string): string;
+}

package/dist/interprompt/multilang_prompt.js

@@ -0,0 +1,302 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'yaml';
+import { createSerenaLogger } from '../serena/util/logging.js';
+import { JinjaTemplate } from './jinja_template.js';
+const { logger: log } = createSerenaLogger({ name: 'interprompt.multilang_prompt' });
+export const DEFAULT_LANG_CODE = 'default';
+export var LanguageFallbackMode;
+(function (LanguageFallbackMode) {
+    LanguageFallbackMode["ANY"] = "any";
+    LanguageFallbackMode["EXCEPTION"] = "exception";
+    LanguageFallbackMode["USE_DEFAULT_LANG"] = "use_default_lang";
+})(LanguageFallbackMode || (LanguageFallbackMode = {}));
+export class PromptTemplate {
+    name;
+    template;
+    constructor(name, templateString) {
+        this.name = name;
+        this.template = new JinjaTemplate(templateString);
+    }
+    render(params) {
+        return this.template.render(params);
+    }
+    getParameters() {
+        return this.template.getParameters();
+    }
+}
+export class PromptList {
+    items;
+    constructor(items) {
+        this.items = items.map((item) => item.trim());
+    }
+    toString() {
+        const bullet = ' * ';
+        const indent = ' '.repeat(bullet.length);
+        return this.items
+            .map((item) => item.replace(/\n/g, `\n${indent}`))
+            .map((item, index) => (index === 0 ? `${bullet}${item}` : `${bullet}${item}`))
+            .join('\n');
+    }
+}
+class MultiLangContainer {
+    name;
+    lang2item = new Map();
+    constructor(name) {
+        this.name = name;
+    }
+    get languageCodes() {
+        return Array.from(this.lang2item.keys());
+    }
+    addItem(item, langCode, allowOverwrite) {
+        if (!allowOverwrite && this.lang2item.has(langCode)) {
+            throw new Error(`Item for language '${langCode}' already registered for '${this.name}'`);
+        }
+        this.lang2item.set(langCode, item);
+    }
+    hasItem(langCode) {
+        return this.lang2item.has(langCode);
+    }
+    getItem(langCode, fallbackMode) {
+        const existing = this.lang2item.get(langCode);
+        if (existing) {
+            return existing;
+        }
+        if (fallbackMode === LanguageFallbackMode.ANY) {
+            const iterator = this.lang2item.values().next();
+            if (iterator.done || iterator.value === undefined) {
+                throw new Error(`No items registered for any language in container '${this.name}'`);
+            }
+            return iterator.value;
+        }
+        if (fallbackMode === LanguageFallbackMode.USE_DEFAULT_LANG) {
+            const fallback = this.lang2item.get(DEFAULT_LANG_CODE);
+            if (fallback) {
+                return fallback;
+            }
+            throw new Error(`Item not found for language '${langCode}' nor for default language '${DEFAULT_LANG_CODE}' in container '${this.name}'`);
+        }
+        throw new Error(`Item for language '${langCode}' not found in container '${this.name}'`);
+    }
+}
+export class MultiLangPromptTemplate {
+    container;
+    constructor(name) {
+        this.container = new MultiLangContainer(name);
+    }
+    get name() {
+        return this.container.name;
+    }
+    get length() {
+        return this.container.languageCodes.length;
+    }
+    addPromptTemplate(template, langCode, allowOverwrite) {
+        if (this.length > 0) {
+            const currentParameters = this.getParameters();
+            const newParameters = template.getParameters();
+            if (JSON.stringify(currentParameters) !== JSON.stringify(newParameters)) {
+                throw new Error(`Cannot add prompt template for language '${langCode}' to '${this.name}' because parameters differ`);
+            }
+        }
+        this.container.addItem(template, langCode, allowOverwrite);
+    }
+    hasItem(langCode) {
+        return this.container.hasItem(langCode);
+    }
+    getPromptTemplate(langCode, fallbackMode) {
+        return this.container.getItem(langCode, fallbackMode);
+    }
+    getParameters() {
+        if (this.length === 0) {
+            throw new Error(`No prompt templates registered for '${this.name}'`);
+        }
+        const [firstLanguage] = this.container.languageCodes;
+        if (!firstLanguage) {
+            throw new Error(`No languages registered for '${this.name}'`);
+        }
+        return this.container.getItem(firstLanguage, LanguageFallbackMode.EXCEPTION).getParameters();
+    }
+}
+export class MultiLangPromptList {
+    container;
+    constructor(name) {
+        this.container = new MultiLangContainer(name);
+    }
+    addPromptList(list, langCode, allowOverwrite) {
+        this.container.addItem(list, langCode, allowOverwrite);
+    }
+    hasItem(langCode) {
+        return this.container.hasItem(langCode);
+    }
+    getPromptList(langCode, fallbackMode) {
+        return this.container.getItem(langCode, fallbackMode);
+    }
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function resolveLangCode(...candidates) {
+    for (const candidate of candidates) {
+        if (isPlainObject(candidate)) {
+            const lang = candidate.lang;
+            if (typeof lang === 'string' && lang.length > 0) {
+                return lang;
+            }
+        }
+    }
+    return DEFAULT_LANG_CODE;
+}
+function preparePromptEntries(data) {
+    if (!isPlainObject(data)) {
+        return [];
+    }
+    const record = data;
+    const result = [];
+    for (const key of Object.keys(record)) {
+        if (key === 'lang') {
+            continue;
+        }
+        result.push([key, record[key]]);
+    }
+    return result;
+}
+function isStringArray(values) {
+    return values.every((value) => typeof value === 'string');
+}
+export class MultiLangPromptCollection {
+    promptTemplates = new Map();
+    promptLists = new Map();
+    _fallbackMode;
+    constructor(promptsDir, fallbackMode = LanguageFallbackMode.EXCEPTION) {
+        const directories = Array.isArray(promptsDir) ? promptsDir : [promptsDir];
+        if (directories.length === 0) {
+            throw new Error('At least one prompts directory must be provided');
+        }
+        const [primary, ...fallbacks] = directories;
+        this.loadFromDisk(primary, { onNameCollision: 'raise' });
+        for (const fallback of fallbacks) {
+            this.loadFromDisk(fallback, { onNameCollision: 'skip' });
+        }
+        this._fallbackMode = fallbackMode;
+    }
+    get fallbackMode() {
+        return this._fallbackMode;
+    }
+    set fallbackMode(mode) {
+        this._fallbackMode = mode;
+    }
+    loadFromDisk(directory, options) {
+        const entries = fs.readdirSync(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile()) {
+                continue;
+            }
+            if (!entry.name.endsWith('.yml') && !entry.name.endsWith('.yaml')) {
+                log.debug(`Skipping non-YAML file: ${entry.name}`);
+                continue;
+            }
+            const absolutePath = path.join(directory, entry.name);
+            const fileContents = fs.readFileSync(absolutePath, 'utf-8');
+            let parsed;
+            try {
+                parsed = yaml.parse(fileContents);
+            }
+            catch (error) {
+                throw new Error(`Failed to parse prompt yaml file ${absolutePath}: ${error.message}`);
+            }
+            if (typeof parsed !== 'object' || parsed === null || !('prompts' in parsed)) {
+                throw new Error(`Invalid YAML structure in ${absolutePath}; missing 'prompts' key`);
+            }
+            const promptsSection = parsed.prompts;
+            const langCode = resolveLangCode(parsed, promptsSection);
+            const promptEntries = preparePromptEntries(promptsSection);
+            for (const [promptName, promptValue] of promptEntries) {
+                if (Array.isArray(promptValue)) {
+                    if (isStringArray(promptValue)) {
+                        this.addPromptList(promptName, [...promptValue], langCode, options.onNameCollision);
+                        continue;
+                    }
+                    throw new Error(`Prompt list '${promptName}' in ${absolutePath} must contain only strings`);
+                }
+                else if (typeof promptValue === 'string') {
+                    this.addPromptTemplate(promptName, promptValue, langCode, options.onNameCollision);
+                }
+                else {
+                    throw new Error(`Invalid prompt entry '${promptName}' in ${absolutePath}; expected string or list, received ${typeof promptValue}`);
+                }
+            }
+        }
+    }
+    addPromptTemplate(name, templateString, langCode, onNameCollision) {
+        const promptTemplate = new PromptTemplate(name, templateString);
+        let container = this.promptTemplates.get(name);
+        if (!container) {
+            container = new MultiLangPromptTemplate(name);
+            this.promptTemplates.set(name, container);
+        }
+        const allowOverwrite = onNameCollision === 'overwrite';
+        if (container.hasItem(langCode)) {
+            if (onNameCollision === 'skip') {
+                log.debug(`Skipping prompt '${name}' for language '${langCode}' because it already exists`);
+                return;
+            }
+            if (onNameCollision === 'raise') {
+                throw new Error(`Prompt '${name}' for language '${langCode}' already exists`);
+            }
+        }
+        container.addPromptTemplate(promptTemplate, langCode, allowOverwrite);
+    }
+    addPromptList(name, promptValues, langCode, onNameCollision) {
+        const promptList = new PromptList(promptValues);
+        let container = this.promptLists.get(name);
+        if (!container) {
+            container = new MultiLangPromptList(name);
+            this.promptLists.set(name, container);
+        }
+        const allowOverwrite = onNameCollision === 'overwrite';
+        if (container.hasItem(langCode)) {
+            if (onNameCollision === 'skip') {
+                log.debug(`Skipping prompt list '${name}' for language '${langCode}' because it already exists`);
+                return;
+            }
+            if (onNameCollision === 'raise') {
+                throw new Error(`Prompt list '${name}' for language '${langCode}' already exists`);
+            }
+        }
+        container.addPromptList(promptList, langCode, allowOverwrite);
+    }
+    getPromptTemplateNames() {
+        return Array.from(this.promptTemplates.keys());
+    }
+    getPromptListNames() {
+        return Array.from(this.promptLists.keys());
+    }
+    getPromptTemplate(name, langCode) {
+        const container = this.promptTemplates.get(name);
+        if (!container) {
+            throw new Error(`Prompt template '${name}' not found`);
+        }
+        return container.getPromptTemplate(langCode, this._fallbackMode);
+    }
+    getPromptTemplateParameters(name) {
+        const container = this.promptTemplates.get(name);
+        if (!container) {
+            throw new Error(`Prompt template '${name}' not found`);
+        }
+        return container.getParameters();
+    }
+    getPromptList(name, langCode) {
+        const container = this.promptLists.get(name);
+        if (!container) {
+            throw new Error(`Prompt list '${name}' not found`);
+        }
+        return container.getPromptList(langCode, this._fallbackMode);
+    }
+    hasPromptTemplate(name, langCode) {
+        return this.promptTemplates.get(name)?.hasItem(langCode) ?? false;
+    }
+    renderPromptTemplate(name, params, langCode) {
+        const template = this.getPromptTemplate(name, langCode);
+        return template.render(params);
+    }
+}

package/dist/interprompt/prompt_factory.d.ts

@@ -0,0 +1,16 @@
+import { MultiLangPromptCollection, type PromptList } from './multilang_prompt.js';
+import type { LanguageFallbackMode } from './multilang_prompt.js';
+export interface PromptFactoryBaseOptions {
+    promptsDir: string | string[];
+    langCode?: string;
+    fallbackMode?: LanguageFallbackMode;
+}
+export declare class PromptFactoryBase {
+    protected readonly langCode: string;
+    protected readonly promptCollection: MultiLangPromptCollection;
+    constructor(options: PromptFactoryBaseOptions);
+    protected renderPromptTemplate(promptName: string, params: Record<string, unknown>): string;
+    protected getPromptList(promptName: string): PromptList;
+}
+export { PromptList, DEFAULT_LANG_CODE, LanguageFallbackMode } from './multilang_prompt.js';
+export declare function autogeneratePromptFactoryModule(promptsDir: string | string[], targetModulePath: string): void;

package/dist/interprompt/prompt_factory.js

@@ -0,0 +1,189 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createSerenaLogger } from '../serena/util/logging.js';
+import { MultiLangPromptCollection, DEFAULT_LANG_CODE } from './multilang_prompt.js';
+export class PromptFactoryBase {
+    langCode;
+    promptCollection;
+    constructor(options) {
+        this.langCode = options.langCode ?? DEFAULT_LANG_CODE;
+        this.promptCollection = new MultiLangPromptCollection(options.promptsDir, options.fallbackMode);
+    }
+    renderPromptTemplate(promptName, params) {
+        const safeParams = { ...params };
+        delete safeParams.self;
+        return this.promptCollection.renderPromptTemplate(promptName, safeParams, this.langCode);
+    }
+    getPromptList(promptName) {
+        return this.promptCollection.getPromptList(promptName, this.langCode);
+    }
+}
+export { PromptList, DEFAULT_LANG_CODE, LanguageFallbackMode } from './multilang_prompt.js';
+const MODULE_PATH = fileURLToPath(import.meta.url);
+const MODULE_JS_PATH = MODULE_PATH.replace(/\.ts$/, '.js');
+const { logger: promptFactoryLogger } = createSerenaLogger({ name: 'interprompt.prompt_factory' });
+function toPascalCase(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter((segment) => segment.length > 0)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    if (pascal.length === 0) {
+        return pascal;
+    }
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toPosixPath(value) {
+    return value.replace(/\\/g, '/');
+}
+function inferParamSpec(templateName, paramName) {
+    const snake = paramName;
+    const camel = toCamelCase(paramName);
+    const lower = paramName.toLowerCase();
+    let type = 'unknown';
+    let optional = false;
+    let needsArrayConversion = false;
+    if (lower === 'system') {
+        type = 'string';
+    }
+    else if (lower.endsWith('_prompt')) {
+        type = 'string';
+    }
+    else if (lower.endsWith('_prompts') || lower.endsWith('_tools') || lower.endsWith('_markers')) {
+        type = 'Iterable<string>';
+        needsArrayConversion = true;
+    }
+    else if (lower.endsWith('_dir') || lower.endsWith('_path')) {
+        type = 'string';
+    }
+    if (templateName === 'prepare_for_new_conversation' && lower === 'mode_prepare_for_new_conversation') {
+        type = 'string | undefined';
+        optional = true;
+    }
+    return { snake, camel, type, optional, needsArrayConversion };
+}
+function normalizeImportPath(from, to) {
+    const relative = path.relative(from, to);
+    const normalized = toPosixPath(relative.startsWith('.') ? relative : `./${relative}`);
+    return normalized.endsWith('.js') ? normalized : `${normalized}.js`;
+}
+export function autogeneratePromptFactoryModule(promptsDir, targetModulePath) {
+    const collection = new MultiLangPromptCollection(promptsDir);
+    const dir = path.dirname(targetModulePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const templateNames = [...collection.getPromptTemplateNames()].sort();
+    const promptListNames = [...collection.getPromptListNames()].sort();
+    const templateSpecs = templateNames.map((name) => ({
+        name,
+        pascal: toPascalCase(name),
+        camel: `create${toPascalCase(name)}`,
+        snake: `create_${name}`,
+        params: collection.getPromptTemplateParameters(name).map((param) => inferParamSpec(name, param))
+    }));
+    const promptListSpecs = promptListNames.map((name) => ({
+        name,
+        pascal: toPascalCase(name),
+        camel: `getList${toPascalCase(name)}`,
+        snake: `get_list_${name}`
+    }));
+    const importPath = normalizeImportPath(dir, MODULE_JS_PATH);
+    const lines = [];
+    lines.push('// NOTE: This module is auto-generated via interprompt.autogeneratePromptFactoryModule. Do not edit manually.');
+    lines.push('');
+    lines.push('import {');
+    lines.push('  PromptFactoryBase,');
+    lines.push('  type PromptFactoryBaseOptions,');
+    if (promptListSpecs.length > 0) {
+        lines.push('  type PromptList');
+    }
+    lines.push(`} from '${importPath}';`);
+    lines.push('');
+    for (const spec of templateSpecs) {
+        if (spec.params.length === 0) {
+            continue;
+        }
+        const interfaceName = `Create${spec.pascal}Params`;
+        lines.push(`export interface ${interfaceName} {`);
+        for (const param of spec.params) {
+            const optionalMark = param.optional ? '?' : '';
+            lines.push(`  ${param.camel}${optionalMark}: ${param.type};`);
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    lines.push('export class PromptFactory extends PromptFactoryBase {');
+    for (const spec of templateSpecs) {
+        const typeAnnotation = spec.params.length === 0 ? '() => string' : `(params: Create${spec.pascal}Params) => string`;
+        lines.push(`  declare ${spec.snake}: ${typeAnnotation};`);
+    }
+    if (promptListSpecs.length > 0) {
+        for (const spec of promptListSpecs) {
+            lines.push(`  declare ${spec.snake}: () => PromptList;`);
+        }
+    }
+    if (templateSpecs.length > 0 || promptListSpecs.length > 0) {
+        lines.push('');
+    }
+    lines.push('  constructor(options: PromptFactoryBaseOptions) {');
+    lines.push('    super(options);');
+    for (const spec of templateSpecs) {
+        const callArgs = spec.params.length === 0 ? '' : 'params';
+        const arrowParams = spec.params.length === 0 ? '' : 'params';
+        const assignment = spec.params.length === 0
+            ? `    this.${spec.snake} = () => this.${spec.camel}();`
+            : `    this.${spec.snake} = (${arrowParams}) => this.${spec.camel}(${callArgs});`;
+        lines.push(assignment);
+    }
+    if (promptListSpecs.length > 0) {
+        for (const spec of promptListSpecs) {
+            lines.push(`    this.${spec.snake} = () => this.${spec.camel}();`);
+        }
+    }
+    lines.push('  }');
+    lines.push('');
+    for (const spec of templateSpecs) {
+        const methodSignature = spec.params.length === 0
+            ? `${spec.camel}(): string`
+            : `${spec.camel}(params: Create${spec.pascal}Params): string`;
+        lines.push(`  ${methodSignature} {`);
+        if (spec.params.length === 0) {
+            lines.push(`    return this.renderPromptTemplate('${spec.name}', {});`);
+        }
+        else {
+            lines.push('    return this.renderPromptTemplate(');
+            lines.push(`      '${spec.name}',`);
+            lines.push('      {');
+            for (let index = 0; index < spec.params.length; index += 1) {
+                const param = spec.params[index];
+                const suffix = index === spec.params.length - 1 ? '' : ',';
+                if (param.needsArrayConversion) {
+                    lines.push(`        ${param.snake}: Array.from(params.${param.camel} ?? [])${suffix}`);
+                }
+                else {
+                    lines.push(`        ${param.snake}: params.${param.camel}${suffix}`);
+                }
+            }
+            lines.push('      }');
+            lines.push('    );');
+        }
+        lines.push('  }');
+        lines.push('');
+    }
+    if (promptListSpecs.length > 0) {
+        for (const spec of promptListSpecs) {
+            lines.push(`  ${spec.camel}(): PromptList {`);
+            lines.push(`    return this.getPromptList('${spec.name}');`);
+            lines.push('  }');
+            lines.push('');
+        }
+    }
+    lines.push('}');
+    lines.push('');
+    const fileContents = `${lines.join('\n').trimEnd()}\n`;
+    fs.writeFileSync(targetModulePath, fileContents, 'utf-8');
+    promptFactoryLogger.info(`Prompt factory generated successfully at ${targetModulePath}`);
+}

package/dist/interprompt/util/class_decorators.d.ts

@@ -0,0 +1 @@
+export { singleton } from '../../serena/util/class_decorators.js';

package/dist/interprompt/util/class_decorators.js

@@ -0,0 +1 @@
+export { singleton } from '../../serena/util/class_decorators.js';

package/dist/interprompt/util/index.d.ts

@@ -0,0 +1 @@
+export { singleton } from './class_decorators.js';

package/dist/interprompt/util/index.js

@@ -0,0 +1 @@
+export { singleton } from './class_decorators.js';