@nogataka/smart-edit 0.0.16 → 0.3.0

package/dist/serena/agno.d.ts

@@ -1,111 +0,0 @@
-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

@@ -1,278 +0,0 @@
-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: 'smart-edit.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/cli.d.ts

@@ -1,9 +0,0 @@
-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;

package/dist/serena/constants.d.ts

@@ -1,18 +0,0 @@
-export declare const SERENA_MANAGED_DIR_NAME = ".smart-edit";
-export declare const SERENA_MANAGED_DIR_IN_HOME: string;
-export declare const REPO_ROOT: string;
-export declare const PROMPT_TEMPLATES_DIR_INTERNAL: string;
-export declare const PROMPT_TEMPLATES_DIR_IN_USER_HOME: string;
-export declare const SERENAS_OWN_CONTEXT_YAMLS_DIR: string;
-export declare const USER_CONTEXT_YAMLS_DIR: string;
-export declare const SERENAS_OWN_MODE_YAMLS_DIR: string;
-export declare const USER_MODE_YAMLS_DIR: string;
-export declare const INTERNAL_MODE_YAMLS_DIR: string;
-export declare const SERENA_DASHBOARD_DIR: string;
-export declare const SERENA_ICON_DIR: string;
-export declare const DEFAULT_ENCODING = "utf-8";
-export declare const DEFAULT_CONTEXT = "desktop-app";
-export declare const DEFAULT_MODES: readonly ["interactive", "editing"];
-export declare const PROJECT_TEMPLATE_FILE: string;
-export declare const SERENA_CONFIG_TEMPLATE_FILE: string;
-export declare const SERENA_LOG_FORMAT = "%(levelname)-5s %(asctime)-15s [%(threadName)s] %(name)s:%(funcName)s:%(lineno)d - %(message)s";

package/dist/serena/constants.js

@@ -1,27 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const repoRoot = path.resolve(__dirname, '..', '..');
-const serenaPackageRoot = path.resolve(__dirname);
-const serenaManagedDirName = '.smart-edit';
-const serenaManagedDirInHome = path.join(os.homedir(), serenaManagedDirName);
-export const SERENA_MANAGED_DIR_NAME = serenaManagedDirName;
-export const SERENA_MANAGED_DIR_IN_HOME = serenaManagedDirInHome;
-export const REPO_ROOT = repoRoot;
-export const PROMPT_TEMPLATES_DIR_INTERNAL = path.join(serenaPackageRoot, 'resources', 'config', 'prompt_templates');
-export const PROMPT_TEMPLATES_DIR_IN_USER_HOME = path.join(serenaManagedDirInHome, 'prompt_templates');
-export const SERENAS_OWN_CONTEXT_YAMLS_DIR = path.join(serenaPackageRoot, 'resources', 'config', 'contexts');
-export const USER_CONTEXT_YAMLS_DIR = path.join(serenaManagedDirInHome, 'contexts');
-export const SERENAS_OWN_MODE_YAMLS_DIR = path.join(serenaPackageRoot, 'resources', 'config', 'modes');
-export const USER_MODE_YAMLS_DIR = path.join(serenaManagedDirInHome, 'modes');
-export const INTERNAL_MODE_YAMLS_DIR = path.join(serenaPackageRoot, 'resources', 'config', 'internal_modes');
-export const SERENA_DASHBOARD_DIR = path.join(serenaPackageRoot, 'resources', 'dashboard');
-export const SERENA_ICON_DIR = path.join(serenaPackageRoot, 'resources', 'icons');
-export const DEFAULT_ENCODING = 'utf-8';
-export const DEFAULT_CONTEXT = 'desktop-app';
-export const DEFAULT_MODES = ['interactive', 'editing'];
-export const PROJECT_TEMPLATE_FILE = path.join(serenaPackageRoot, 'resources', 'project.template.yml');
-export const SERENA_CONFIG_TEMPLATE_FILE = path.join(serenaPackageRoot, 'resources', 'serena_config.template.yml');
-export const SERENA_LOG_FORMAT = '%(levelname)-5s %(asctime)-15s [%(threadName)s] %(name)s:%(funcName)s:%(lineno)d - %(message)s';