@nogataka/smart-edit 0.0.14

package/dist/serena/agno.d.ts

@@ -0,0 +1,111 @@
+import type { Tool, ToolApplyFunction, ToolApplyMetadata } from './tools/tools_base.js';
+import { SerenaAgent } from './agent.js';
+export interface SerenaAgnoFunctionDefinition {
+    readonly name: string;
+    readonly apply: ToolApplyFunction<Record<string, unknown>, string>;
+    readonly entrypoint: (args: Record<string, unknown>) => Promise<string>;
+    readonly skipEntrypointProcessing: boolean;
+    readonly metadata: ToolApplyMetadata;
+    readonly tool: Tool;
+}
+export interface SerenaAgnoToolkitData {
+    readonly name: string;
+    readonly functions: Record<string, SerenaAgnoFunctionDefinition>;
+    readonly functionList: SerenaAgnoFunctionDefinition[];
+}
+export interface SerenaAgnoAgentFactoryOptions {
+    name: string;
+    model: unknown;
+    description: string;
+    toolkits: unknown[];
+    storage: unknown;
+    systemMessage: string;
+    showToolCalls: boolean;
+    markdown: boolean;
+    telemetry: boolean;
+    memory: unknown;
+    addHistoryToMessages: boolean;
+    numHistoryResponses: number;
+}
+export interface SerenaAgnoIntegration {
+    createToolkit(data: SerenaAgnoToolkitData): unknown;
+    createAgent(options: SerenaAgnoAgentFactoryOptions): unknown;
+    createMemory(): unknown;
+    createStorage(options: {
+        tableName: string;
+        dbFile: string;
+    }): unknown;
+}
+export declare class DefaultAgnoFunction {
+    readonly name: string;
+    entrypoint: (args: Record<string, unknown>) => Promise<string>;
+    skipEntrypointProcessing: boolean;
+    readonly apply: ToolApplyFunction<Record<string, unknown>, string>;
+    readonly metadata: ToolApplyMetadata;
+    constructor(definition: SerenaAgnoFunctionDefinition);
+}
+export declare class DefaultAgnoToolkit {
+    readonly name: string;
+    readonly functions: Record<string, DefaultAgnoFunction>;
+    constructor(data: SerenaAgnoToolkitData);
+}
+export declare class DefaultAgnoAgentMemory {
+}
+export declare class DefaultAgnoSqliteStorage {
+    readonly tableName: string;
+    readonly dbFile: string;
+    constructor(options: {
+        tableName: string;
+        dbFile: string;
+    });
+}
+export declare class DefaultAgnoAgent {
+    readonly name: string;
+    readonly model: unknown;
+    readonly description: string;
+    readonly toolkits: DefaultAgnoToolkit[];
+    readonly storage: DefaultAgnoSqliteStorage;
+    readonly systemMessage: string;
+    readonly options: Omit<SerenaAgnoAgentFactoryOptions, 'name' | 'model' | 'description' | 'toolkits' | 'storage' | 'systemMessage'>;
+    constructor(config: SerenaAgnoAgentFactoryOptions & {
+        toolkits: DefaultAgnoToolkit[];
+        storage: DefaultAgnoSqliteStorage;
+    });
+    toString(): string;
+}
+export declare class DefaultSerenaAgnoIntegration implements SerenaAgnoIntegration {
+    createToolkit(data: SerenaAgnoToolkitData): DefaultAgnoToolkit;
+    createAgent(options: SerenaAgnoAgentFactoryOptions): DefaultAgnoAgent;
+    createMemory(): DefaultAgnoAgentMemory;
+    createStorage(options: {
+        tableName: string;
+        dbFile: string;
+    }): DefaultAgnoSqliteStorage;
+}
+export declare function configureSerenaAgnoIntegration(integration: SerenaAgnoIntegration): void;
+export declare function getSerenaAgnoIntegration(): SerenaAgnoIntegration;
+export declare class SerenaAgnoToolkit {
+    readonly name: string;
+    readonly functions: Record<string, SerenaAgnoFunctionDefinition>;
+    constructor(serenaAgent: {
+        getExposedToolInstances(): Iterable<Tool>;
+    });
+    toToolkitData(): SerenaAgnoToolkitData;
+    buildToolkit(integration?: SerenaAgnoIntegration): unknown;
+    static createFunctionDefinition(tool: Tool): SerenaAgnoFunctionDefinition;
+}
+export interface SerenaAgnoAgentProviderOptions {
+    argv?: string[];
+    integration?: SerenaAgnoIntegration;
+    projectFileOverride?: string | null;
+    serenaAgentFactory?: (projectFile: string | null) => SerenaAgent;
+}
+export declare class SerenaAgnoAgentProvider {
+    private static agent;
+    private static serenaAgentFactoryOverride;
+    static configure(options?: {
+        serenaAgentFactory?: (projectFile: string | null) => SerenaAgent;
+    }): void;
+    static reset(): void;
+    static getAgent(model: unknown, options?: SerenaAgnoAgentProviderOptions): unknown;
+}

package/dist/serena/agno.js

@@ -0,0 +1,278 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { createRequire } from 'node:module';
+import { createSerenaLogger } from './util/logging.js';
+import { REPO_ROOT } from './constants.js';
+import { SerenaAgent } from './agent.js';
+import { SerenaAgentContext } from './config/context_mode.js';
+import { showFatalExceptionSafe } from './util/exception.js';
+const { logger: log } = createSerenaLogger({ name: 'serena.agno' });
+const DEFAULT_TOOLKIT_NAME = 'Serena';
+const DEFAULT_SQLITE_TABLE_NAME = 'serena_agent_sessions';
+const DEFAULT_SQLITE_RELATIVE_PATH = path.join('temp', 'agno_agent_storage.db');
+function now() {
+    return process.hrtime.bigint();
+}
+function formatDurationMs(start, end) {
+    const durationMs = Number(end - start) / 1_000_000;
+    return `${durationMs.toFixed(2)}ms`;
+}
+function loadDotenvIfAvailable() {
+    try {
+        const require = createRequire(import.meta.url);
+        const maybeDotenv = require('dotenv');
+        if (maybeDotenv && typeof maybeDotenv.config === 'function') {
+            maybeDotenv.config();
+            log.debug('Loaded environment variables using dotenv.');
+        }
+    }
+    catch (error) {
+        log.debug(`dotenv not available or failed to load: ${String(error)}`);
+    }
+}
+export class DefaultAgnoFunction {
+    name;
+    entrypoint;
+    skipEntrypointProcessing;
+    apply;
+    metadata;
+    constructor(definition) {
+        this.name = definition.name;
+        this.apply = definition.apply;
+        this.entrypoint = definition.entrypoint;
+        this.skipEntrypointProcessing = definition.skipEntrypointProcessing;
+        this.metadata = definition.metadata;
+    }
+}
+export class DefaultAgnoToolkit {
+    name;
+    functions = {};
+    constructor(data) {
+        this.name = data.name;
+        for (const definition of data.functionList) {
+            this.functions[definition.name] = new DefaultAgnoFunction(definition);
+        }
+    }
+}
+export class DefaultAgnoAgentMemory {
+}
+export class DefaultAgnoSqliteStorage {
+    tableName;
+    dbFile;
+    constructor(options) {
+        this.tableName = options.tableName;
+        this.dbFile = options.dbFile;
+    }
+}
+export class DefaultAgnoAgent {
+    name;
+    model;
+    description;
+    toolkits;
+    storage;
+    systemMessage;
+    options;
+    constructor(config) {
+        this.name = config.name;
+        this.model = config.model;
+        this.description = config.description;
+        this.toolkits = config.toolkits;
+        this.storage = config.storage;
+        this.systemMessage = config.systemMessage;
+        this.options = {
+            addHistoryToMessages: config.addHistoryToMessages,
+            markdown: config.markdown,
+            memory: config.memory,
+            numHistoryResponses: config.numHistoryResponses,
+            showToolCalls: config.showToolCalls,
+            telemetry: config.telemetry
+        };
+    }
+    toString() {
+        return `${this.name} Agent (toolkits=${this.toolkits.length})`;
+    }
+}
+export class DefaultSerenaAgnoIntegration {
+    createToolkit(data) {
+        return new DefaultAgnoToolkit(data);
+    }
+    createAgent(options) {
+        const storage = options.storage instanceof DefaultAgnoSqliteStorage
+            ? options.storage
+            : new DefaultAgnoSqliteStorage({
+                tableName: DEFAULT_SQLITE_TABLE_NAME,
+                dbFile: path.resolve(REPO_ROOT, DEFAULT_SQLITE_RELATIVE_PATH)
+            });
+        const toolkits = options.toolkits.map((toolkit) => toolkit instanceof DefaultAgnoToolkit
+            ? toolkit
+            : new DefaultAgnoToolkit({ name: DEFAULT_TOOLKIT_NAME, functions: {}, functionList: [] }));
+        const configWithDefaults = {
+            name: options.name,
+            model: options.model,
+            description: options.description,
+            toolkits,
+            storage,
+            systemMessage: options.systemMessage,
+            showToolCalls: options.showToolCalls,
+            markdown: options.markdown,
+            telemetry: options.telemetry,
+            memory: options.memory,
+            addHistoryToMessages: options.addHistoryToMessages,
+            numHistoryResponses: options.numHistoryResponses
+        };
+        return new DefaultAgnoAgent(configWithDefaults);
+    }
+    createMemory() {
+        return new DefaultAgnoAgentMemory();
+    }
+    createStorage(options) {
+        return new DefaultAgnoSqliteStorage(options);
+    }
+}
+let activeIntegration = new DefaultSerenaAgnoIntegration();
+export function configureSerenaAgnoIntegration(integration) {
+    activeIntegration = integration;
+}
+export function getSerenaAgnoIntegration() {
+    return activeIntegration;
+}
+function normalizeKwargs(rawArgs) {
+    if (!('kwargs' in rawArgs)) {
+        return { ...rawArgs };
+    }
+    const { kwargs, ...rest } = rawArgs;
+    if (kwargs && typeof kwargs === 'object' && !Array.isArray(kwargs)) {
+        return { ...rest, ...kwargs };
+    }
+    return rest;
+}
+function resolveProjectArgument(argv) {
+    let pendingFlag = null;
+    for (const arg of argv) {
+        if (pendingFlag) {
+            return typeof arg === 'string' ? arg : null;
+        }
+        if (arg.startsWith('--project=')) {
+            return arg.slice('--project='.length);
+        }
+        if (arg.startsWith('--project-file=')) {
+            return arg.slice('--project-file='.length);
+        }
+        if (arg === '--project' || arg === '--project-file') {
+            pendingFlag = arg;
+        }
+    }
+    return null;
+}
+export class SerenaAgnoToolkit {
+    name = DEFAULT_TOOLKIT_NAME;
+    functions = {};
+    constructor(serenaAgent) {
+        const toolInstances = serenaAgent.getExposedToolInstances();
+        for (const tool of toolInstances) {
+            const definition = SerenaAgnoToolkit.createFunctionDefinition(tool);
+            this.functions[definition.name] = definition;
+        }
+        log.info(`Agno agent functions: ${Object.keys(this.functions).join(', ')}`);
+    }
+    toToolkitData() {
+        const functionList = Object.values(this.functions);
+        return {
+            name: this.name,
+            functions: { ...this.functions },
+            functionList
+        };
+    }
+    buildToolkit(integration = getSerenaAgnoIntegration()) {
+        return integration.createToolkit(this.toToolkitData());
+    }
+    static createFunctionDefinition(tool) {
+        const toolClass = tool.constructor;
+        const name = toolClass.getNameFromCls();
+        const applyFn = tool.getApplyFn();
+        const metadata = tool.getApplyFnMetadata();
+        const entrypoint = async (rawArgs) => {
+            const normalizedArgs = normalizeKwargs(rawArgs);
+            log.info(`Calling tool ${toolClass.name}`);
+            return tool.applyEx(normalizedArgs, {
+                logCall: true,
+                catchExceptions: true
+            });
+        };
+        return {
+            name,
+            apply: applyFn,
+            entrypoint,
+            skipEntrypointProcessing: true,
+            metadata,
+            tool
+        };
+    }
+}
+export class SerenaAgnoAgentProvider {
+    static agent = null;
+    static serenaAgentFactoryOverride = null;
+    static configure(options = {}) {
+        this.serenaAgentFactoryOverride = options.serenaAgentFactory ?? null;
+    }
+    static reset() {
+        this.agent = null;
+    }
+    static getAgent(model, options = {}) {
+        if (this.agent) {
+            return this.agent;
+        }
+        process.chdir(REPO_ROOT);
+        loadDotenvIfAvailable();
+        const argv = options.argv ?? process.argv.slice(2);
+        const projectFlagValue = options.projectFileOverride ?? resolveProjectArgument(argv);
+        const projectFile = projectFlagValue ? path.resolve(projectFlagValue) : null;
+        const start = now();
+        let serenaAgent;
+        try {
+            const factory = options.serenaAgentFactory ?? this.serenaAgentFactoryOverride ?? ((project) => new SerenaAgent({
+                project: project ?? undefined,
+                context: SerenaAgentContext.load('agent')
+            }));
+            serenaAgent = factory(projectFile);
+        }
+        catch (error) {
+            void showFatalExceptionSafe(error);
+            throw error;
+        }
+        const end = now();
+        log.info(`Loading Serena agent finished in ${formatDurationMs(start, end)}`);
+        const toolkit = new SerenaAgnoToolkit(serenaAgent);
+        const integration = options.integration ?? getSerenaAgnoIntegration();
+        const toolkitInstance = toolkit.buildToolkit(integration);
+        const sqlitePath = path.resolve(REPO_ROOT, DEFAULT_SQLITE_RELATIVE_PATH);
+        fs.mkdirSync(path.dirname(sqlitePath), { recursive: true });
+        log.info(`Deleting DB from PID ${process.pid}`);
+        if (fs.existsSync(sqlitePath)) {
+            fs.rmSync(sqlitePath);
+        }
+        const storage = integration.createStorage({
+            tableName: DEFAULT_SQLITE_TABLE_NAME,
+            dbFile: sqlitePath
+        });
+        const memory = integration.createMemory();
+        const agent = integration.createAgent({
+            name: DEFAULT_TOOLKIT_NAME,
+            model,
+            description: 'A fully-featured coding assistant',
+            toolkits: [toolkitInstance],
+            storage,
+            systemMessage: serenaAgent.createSystemPrompt(),
+            showToolCalls: false,
+            markdown: true,
+            telemetry: false,
+            memory,
+            addHistoryToMessages: true,
+            numHistoryResponses: 100
+        });
+        this.agent = agent;
+        log.info(`Agent instantiated: ${String(agent)}`);
+        return agent;
+    }
+}

package/dist/serena/analytics.d.ts

@@ -0,0 +1,24 @@
+import { RegisteredTokenCountEstimator } from './config/serena_config.js';
+export interface TokenCountEstimator {
+    estimateTokenCount(text: string): number;
+}
+export declare class ToolUsageStatsEntry {
+    numTimesCalled: number;
+    inputTokens: number;
+    outputTokens: number;
+    constructor(numTimesCalled?: number, inputTokens?: number, outputTokens?: number);
+    updateOnCall(inputTokens: number, outputTokens: number): void;
+    clone(): ToolUsageStatsEntry;
+}
+export declare class ToolUsageStats {
+    private readonly estimator;
+    private readonly estimatorName;
+    private readonly stats;
+    constructor(registry?: RegisteredTokenCountEstimator);
+    get tokenEstimatorName(): string;
+    clear(): void;
+    getStats(toolName: string): ToolUsageStatsEntry;
+    getToolStatsDict(): Record<string, Record<string, number>>;
+    recordToolUsage(toolName: string, input: string, output: string): void;
+}
+export declare function __internalResetEstimatorCacheForTests(): void;

package/dist/serena/analytics.js

@@ -0,0 +1,119 @@
+import { encoding_for_model } from '@dqbd/tiktoken';
+import { createSerenaLogger } from './util/logging.js';
+import { RegisteredTokenCountEstimator } from './config/serena_config.js';
+const { logger } = createSerenaLogger({ name: 'serena.analytics', emitToConsole: false, level: 'info' });
+const DEFAULT_TIKTOKEN_MODEL = 'gpt-4o';
+class ApproximateTokenCountEstimator {
+    estimateTokenCount(text) {
+        const normalized = text.replace(/\s+/g, ' ').trim();
+        if (normalized.length === 0) {
+            return 0;
+        }
+        const roughWordCount = normalized.split(' ').length;
+        return Math.max(1, Math.round((normalized.length + roughWordCount * 2) / 4));
+    }
+}
+class TiktokenCountEstimator {
+    modelName;
+    encoding;
+    constructor(modelName) {
+        this.modelName = modelName;
+        this.encoding = encoding_for_model(modelName);
+        logger.info(`Loading tiktoken encoding for model ${modelName}, this may take a while on the first run.`);
+    }
+    estimateTokenCount(text) {
+        if (text.length === 0) {
+            return 0;
+        }
+        return this.encoding.encode(text).length;
+    }
+}
+class AnthropicTokenCountEstimator {
+    estimateTokenCount(text) {
+        logger.warn('Anthropic token counting is not yet implemented in Node; using approximate estimator.');
+        return approximateEstimator.estimateTokenCount(text);
+    }
+}
+const approximateEstimator = new ApproximateTokenCountEstimator();
+const estimatorCache = new Map();
+function createEstimator(registry) {
+    try {
+        switch (registry) {
+            case RegisteredTokenCountEstimator.TIKTOKEN_GPT4O:
+                return new TiktokenCountEstimator(DEFAULT_TIKTOKEN_MODEL);
+            case RegisteredTokenCountEstimator.ANTHROPIC_CLAUDE_SONNET_4:
+                return new AnthropicTokenCountEstimator();
+            default:
+                logger.warn(`Unknown token count estimator '${String(registry)}', using approximate fallback.`);
+                return approximateEstimator;
+        }
+    }
+    catch (error) {
+        logger.error(`Failed to initialize estimator '${String(registry)}': ${error.message}. Falling back to approximate estimator.`);
+        return approximateEstimator;
+    }
+}
+export class ToolUsageStatsEntry {
+    numTimesCalled;
+    inputTokens;
+    outputTokens;
+    constructor(numTimesCalled = 0, inputTokens = 0, outputTokens = 0) {
+        this.numTimesCalled = numTimesCalled;
+        this.inputTokens = inputTokens;
+        this.outputTokens = outputTokens;
+    }
+    updateOnCall(inputTokens, outputTokens) {
+        this.numTimesCalled += 1;
+        this.inputTokens += inputTokens;
+        this.outputTokens += outputTokens;
+    }
+    clone() {
+        return new ToolUsageStatsEntry(this.numTimesCalled, this.inputTokens, this.outputTokens);
+    }
+}
+export class ToolUsageStats {
+    estimator;
+    estimatorName;
+    stats = new Map();
+    constructor(registry = RegisteredTokenCountEstimator.TIKTOKEN_GPT4O) {
+        let estimator = estimatorCache.get(registry);
+        if (!estimator) {
+            estimator = createEstimator(registry);
+            estimatorCache.set(registry, estimator);
+        }
+        this.estimator = estimator;
+        this.estimatorName = registry;
+    }
+    get tokenEstimatorName() {
+        return this.estimatorName;
+    }
+    clear() {
+        this.stats.clear();
+    }
+    getStats(toolName) {
+        const entry = this.stats.get(toolName);
+        if (entry) {
+            return entry.clone();
+        }
+        return new ToolUsageStatsEntry();
+    }
+    getToolStatsDict() {
+        const result = {};
+        for (const [toolName, entry] of this.stats) {
+            result[toolName] = {
+                numTimesCalled: entry.numTimesCalled,
+                inputTokens: entry.inputTokens,
+                outputTokens: entry.outputTokens
+            };
+        }
+        return result;
+    }
+    recordToolUsage(toolName, input, output) {
+        const entry = this.stats.get(toolName) ?? new ToolUsageStatsEntry();
+        entry.updateOnCall(this.estimator.estimateTokenCount(input), this.estimator.estimateTokenCount(output));
+        this.stats.set(toolName, entry);
+    }
+}
+export function __internalResetEstimatorCacheForTests() {
+    estimatorCache.clear();
+}

package/dist/serena/cli.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+interface CreateCliOptions {
+    writeOut?: (str: string) => void;
+    writeErr?: (str: string) => void;
+    enableExitOverride?: boolean;
+}
+export declare function createSerenaCli(options?: CreateCliOptions): Command;
+export declare function runSerenaCli(argv?: readonly string[]): Promise<void>;
+export default runSerenaCli;