@nogataka/smart-edit 0.0.14

package/dist/serena/tools/workflow_tools.js

@@ -0,0 +1,161 @@
+import os from 'node:os';
+import { Tool, ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional } from './tools_base.js';
+import { ListMemoriesTool } from './memory_tools.js';
+function ensureString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (typeof value === 'symbol') {
+        return value.toString();
+    }
+    if (typeof value === 'function') {
+        return '[function]';
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return Object.prototype.toString.call(value);
+        }
+    }
+    return '';
+}
+async function callPromptFactoryMethod(promptFactory, methodCandidates, ...args) {
+    for (const name of methodCandidates) {
+        const candidate = Reflect.get(promptFactory, name);
+        if (typeof candidate === 'function') {
+            const result = await Promise.resolve(candidate.apply(promptFactory, args));
+            return ensureString(result);
+        }
+    }
+    throw new Error(`Prompt factory does not implement expected method: ${methodCandidates.join(' or ')}`);
+}
+function normalizeSystemName(platformName) {
+    switch (platformName) {
+        case 'win32':
+            return 'Windows';
+        case 'darwin':
+            return 'Darwin';
+        case 'linux':
+            return 'Linux';
+        default:
+            if (platformName.length === 0) {
+                return 'Unknown';
+            }
+            return platformName.charAt(0).toUpperCase() + platformName.slice(1);
+    }
+}
+function getToolInstance(agent, toolClass) {
+    const lookupAgent = agent;
+    if (typeof lookupAgent.getTool === 'function') {
+        return lookupAgent.getTool(toolClass);
+    }
+    if (typeof lookupAgent.get_tool === 'function') {
+        return lookupAgent.get_tool(toolClass);
+    }
+    const FallbackCtor = toolClass;
+    return new FallbackCtor(agent);
+}
+async function callAgentSystemPrompt(agent) {
+    const candidate = agent;
+    if (typeof candidate.createSystemPrompt === 'function') {
+        const result = await Promise.resolve(candidate.createSystemPrompt());
+        return ensureString(result);
+    }
+    if (typeof candidate.create_system_prompt === 'function') {
+        const result = await Promise.resolve(candidate.create_system_prompt());
+        return ensureString(result);
+    }
+    throw new Error('Agent does not implement a system prompt creation method.');
+}
+export class CheckOnboardingPerformedTool extends Tool {
+    static description = 'Checks whether project onboarding was already performed.';
+    async apply(_args = {}) {
+        const listTool = getToolInstance(this.agent, ListMemoriesTool);
+        const raw = await Promise.resolve(listTool.apply());
+        let parsed;
+        try {
+            parsed = JSON.parse(ensureString(raw));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Unable to parse ListMemoriesTool output as JSON: ${message}`);
+        }
+        if (!Array.isArray(parsed)) {
+            throw new Error('ListMemoriesTool returned non-array JSON output.');
+        }
+        if (parsed.length === 0) {
+            return ('Onboarding not performed yet (no memories available). ' +
+                'You should perform onboarding by calling the `onboarding` tool before proceeding with the task.');
+        }
+        const lines = [
+            'The onboarding was already performed, below is the list of available memories.',
+            'Do not read them immediately, just remember that they exist and that you can read them later, if it is necessary',
+            'for the current task.',
+            'Some memories may be based on previous conversations, others may be general for the current project.',
+            'You should be able to tell which one you need based on the name of the memory.',
+            '',
+            JSON.stringify(parsed)
+        ];
+        return lines.join('\n');
+    }
+}
+export class OnboardingTool extends Tool {
+    static description = 'Provides onboarding instructions (project structure, essential tasks, etc.) when onboarding has not been performed.';
+    async apply(_args = {}) {
+        const system = normalizeSystemName(os.platform());
+        const result = await callPromptFactoryMethod(this.promptFactory, ['create_onboarding_prompt', 'createOnboardingPrompt'], { system });
+        return result;
+    }
+}
+export class ThinkAboutCollectedInformationTool extends Tool {
+    static description = 'Encourages the agent to reflect on whether the gathered information is sufficient and relevant.';
+    async apply(_args = {}) {
+        const result = await callPromptFactoryMethod(this.promptFactory, ['create_think_about_collected_information', 'createThinkAboutCollectedInformation']);
+        return result;
+    }
+}
+export class ThinkAboutTaskAdherenceTool extends Tool {
+    static description = 'Guides the agent to confirm alignment with the current task before making code changes.';
+    async apply(_args = {}) {
+        const result = await callPromptFactoryMethod(this.promptFactory, ['create_think_about_task_adherence', 'createThinkAboutTaskAdherence']);
+        return result;
+    }
+}
+export class ThinkAboutWhetherYouAreDoneTool extends Tool {
+    static description = 'Helps determine whether the requested task is fully completed.';
+    async apply(_args = {}) {
+        const result = await callPromptFactoryMethod(this.promptFactory, ['create_think_about_whether_you_are_done', 'createThinkAboutWhetherYouAreDone']);
+        return result;
+    }
+}
+export class SummarizeChangesTool extends Tool {
+    static markers = new Set([ToolMarkerOptional]);
+    static description = 'Provides guidelines for summarizing codebase changes after completing a task.';
+    async apply(_args = {}) {
+        const result = await callPromptFactoryMethod(this.promptFactory, ['create_summarize_changes', 'createSummarizeChanges']);
+        return result;
+    }
+}
+export class PrepareForNewConversationTool extends Tool {
+    static description = 'Provides instructions to prepare for continuing work in a new conversation context.';
+    async apply(_args = {}) {
+        const result = await callPromptFactoryMethod(this.promptFactory, ['create_prepare_for_new_conversation', 'createPrepareForNewConversation']);
+        return result;
+    }
+}
+export class InitialInstructionsTool extends Tool {
+    static markers = new Set([ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional]);
+    static description = 'Returns the initial system instructions for the current project when they cannot be provided via the system prompt.';
+    async apply(_args = {}) {
+        const result = await callAgentSystemPrompt(this.agent);
+        return result;
+    }
+}

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

@@ -0,0 +1,7 @@
+type ClassConstructor<T extends object = object> = abstract new (...args: unknown[]) => T;
+interface DecoratorContextLike {
+    kind?: string;
+    name?: string | symbol;
+}
+export declare function singleton<T extends ClassConstructor>(constructor: T, context?: DecoratorContextLike): T;
+export {};

package/dist/serena/util/class_decorators.js

@@ -0,0 +1,37 @@
+export function singleton(constructor, context) {
+    return wrapAsSingleton(constructor, context);
+}
+function wrapAsSingleton(constructor, context) {
+    let instance;
+    let proxy;
+    const handler = {
+        construct(target, args, newTarget) {
+            if (instance && (newTarget === proxy || newTarget === target)) {
+                return instance;
+            }
+            const actualTarget = newTarget === proxy ? target : newTarget;
+            instance = Reflect.construct(target, args, actualTarget);
+            return instance;
+        },
+        apply(target, thisArg, args) {
+            instance ??= Reflect.construct(target, args, target);
+            return instance;
+        }
+    };
+    proxy = new Proxy(constructor, handler);
+    const desiredName = typeof context?.name === 'string' && context.kind === 'class'
+        ? context.name
+        : constructor.name;
+    if (desiredName && desiredName !== proxy.name) {
+        try {
+            Object.defineProperty(proxy, 'name', {
+                value: desiredName,
+                configurable: true
+            });
+        }
+        catch {
+            // プロキシ化したコンストラクタでは name を再定義できない場合があるが、機能に影響はないため無視する
+        }
+    }
+    return proxy;
+}

package/dist/serena/util/exception.d.ts

@@ -0,0 +1,8 @@
+import type { SerenaLogger } from './logging.js';
+export interface ShowFatalExceptionOptions {
+    logger?: SerenaLogger;
+    printToStderr?: boolean;
+}
+export declare function evaluateHeadlessEnvironment(env: NodeJS.ProcessEnv, platform: NodeJS.Platform, release: string, fileExists: (path: string) => boolean): boolean;
+export declare function isHeadlessEnvironment(): boolean;
+export declare function showFatalExceptionSafe(error: unknown, { logger, printToStderr }?: ShowFatalExceptionOptions): Promise<void>;

package/dist/serena/util/exception.js

@@ -0,0 +1,53 @@
+import { existsSync } from 'node:fs';
+import os from 'node:os';
+import { createSerenaLogger } from './logging.js';
+const { logger: consoleLogger } = createSerenaLogger({ level: 'debug' });
+export function evaluateHeadlessEnvironment(env, platform, release, fileExists) {
+    if (platform === 'win32') {
+        return false;
+    }
+    if (!env.DISPLAY) {
+        return true;
+    }
+    if (env.SSH_CONNECTION || env.SSH_CLIENT) {
+        return true;
+    }
+    if (env.CI || env.CONTAINER || fileExists('/.dockerenv')) {
+        return true;
+    }
+    if (release.toLowerCase().includes('microsoft')) {
+        return true;
+    }
+    return false;
+}
+export function isHeadlessEnvironment() {
+    return evaluateHeadlessEnvironment(process.env, process.platform, os.release(), existsSync);
+}
+export async function showFatalExceptionSafe(error, { logger = consoleLogger, printToStderr = true } = {}) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Fatal exception: ${errorMessage}`, error);
+    if (printToStderr) {
+        if (error instanceof Error && error.stack) {
+            console.error(`Fatal exception: ${error.message}\n${error.stack}`);
+        }
+        else {
+            console.error(`Fatal exception: ${errorMessage}`);
+        }
+    }
+    if (isHeadlessEnvironment()) {
+        logger.debug('Skipping GUI error display in headless environment');
+        return;
+    }
+    try {
+        const { showFatalException } = await import('../gui_log_viewer.js');
+        if (typeof showFatalException === 'function') {
+            await Promise.resolve(showFatalException(error));
+        }
+        else {
+            logger.debug('GUI error display is unavailable: showFatalException not implemented');
+        }
+    }
+    catch (guiError) {
+        logger.debug('Failed to show GUI error dialog', guiError);
+    }
+}

package/dist/serena/util/file_system.d.ts

@@ -0,0 +1,30 @@
+export interface ScanResult {
+    directories: string[];
+    files: string[];
+}
+export type IgnorePredicate = (absolutePath: string) => boolean;
+export declare function scanDirectory(targetPath: string, recursive?: boolean, relativeTo?: string, isIgnoredDir?: IgnorePredicate, isIgnoredFile?: IgnorePredicate): ScanResult;
+export declare function findAllNonIgnoredFiles(repoRoot: string): string[];
+export declare class GitignoreSpec {
+    readonly filePath: string;
+    readonly patterns: string[];
+    private readonly matcher;
+    constructor(filePath: string, patterns: string[]);
+    matches(relativePath: string): boolean;
+}
+export declare class GitignoreParser {
+    readonly repoRoot: string;
+    private ignoreSpecs;
+    constructor(repoRoot: string);
+    shouldIgnore(inputPath: string): boolean;
+    getIgnoreSpecs(): GitignoreSpec[];
+    reload(): void;
+    private loadGitignoreFiles;
+    private iterGitignoreFiles;
+    private createIgnoreSpec;
+    private parseGitignoreContent;
+}
+export interface PathMatcher {
+    ignores(path: string): boolean;
+}
+export declare function matchPath(relativePath: string, matcher: PathMatcher, rootPath?: string): boolean;

package/dist/serena/util/file_system.js

@@ -0,0 +1,352 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import ignore from 'ignore';
+import { createSerenaLogger } from './logging.js';
+const { logger: fileSystemLogger } = createSerenaLogger({
+    level: 'debug',
+    emitToConsole: false,
+    name: 'SerenaFileSystem'
+});
+export function scanDirectory(targetPath, recursive = false, relativeTo, isIgnoredDir, isIgnoredFile) {
+    const ignoreDir = isIgnoredDir ?? (() => false);
+    const ignoreFile = isIgnoredFile ?? (() => false);
+    const files = [];
+    const directories = [];
+    const absolutePath = path.resolve(targetPath);
+    const relativeBase = relativeTo ? path.resolve(relativeTo) : undefined;
+    let entries;
+    try {
+        entries = fs.readdirSync(absolutePath, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isPermissionError(error)) {
+            fileSystemLogger.debug('Skipping directory due to permission error', {
+                path: absolutePath,
+                error
+            });
+            return { directories: [], files: [] };
+        }
+        throw error;
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(absolutePath, entry.name);
+        const resultPath = relativeBase ? path.relative(relativeBase, entryPath) : entryPath;
+        let stats;
+        try {
+            stats = fs.statSync(entryPath);
+        }
+        catch (error) {
+            if (isPermissionError(error)) {
+                fileSystemLogger.debug('Skipping entry due to permission error', {
+                    path: entryPath,
+                    error
+                });
+                continue;
+            }
+            throw error;
+        }
+        if (stats.isFile()) {
+            if (!ignoreFile(entryPath)) {
+                files.push(resultPath);
+            }
+            continue;
+        }
+        if (stats.isDirectory()) {
+            if (!ignoreDir(entryPath)) {
+                directories.push(resultPath);
+                if (recursive) {
+                    const subResult = scanDirectory(entryPath, true, relativeTo, ignoreDir, ignoreFile);
+                    files.push(...subResult.files);
+                    directories.push(...subResult.directories);
+                }
+            }
+            continue;
+        }
+    }
+    return { directories, files };
+}
+export function findAllNonIgnoredFiles(repoRoot) {
+    const parser = new GitignoreParser(repoRoot);
+    const { files } = scanDirectory(repoRoot, true, undefined, parser.shouldIgnore.bind(parser), parser.shouldIgnore.bind(parser));
+    return files;
+}
+export class GitignoreSpec {
+    filePath;
+    patterns;
+    matcher;
+    constructor(filePath, patterns) {
+        this.filePath = filePath;
+        this.patterns = patterns;
+        this.matcher = ignore();
+        if (patterns.length > 0) {
+            this.matcher.add(patterns);
+        }
+    }
+    matches(relativePath) {
+        if (!this.patterns.length) {
+            return false;
+        }
+        const candidate = normalizeCandidate(relativePath);
+        if (candidate === '') {
+            return false;
+        }
+        const withoutLeadingSlash = candidate.startsWith('/') ? candidate.slice(1) : candidate;
+        if (this.matcher.ignores(withoutLeadingSlash)) {
+            return true;
+        }
+        if (withoutLeadingSlash.endsWith('/')) {
+            const withoutTrailing = withoutLeadingSlash.slice(0, -1);
+            if (withoutTrailing && this.matcher.ignores(withoutTrailing)) {
+                return true;
+            }
+        }
+        else {
+            const withTrailing = `${withoutLeadingSlash}/`;
+            if (this.matcher.ignores(withTrailing)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+export class GitignoreParser {
+    repoRoot;
+    ignoreSpecs = [];
+    constructor(repoRoot) {
+        this.repoRoot = path.resolve(repoRoot);
+        this.loadGitignoreFiles();
+    }
+    shouldIgnore(inputPath) {
+        const absolutePath = path.isAbsolute(inputPath)
+            ? path.resolve(inputPath)
+            : path.resolve(this.repoRoot, inputPath);
+        if (!isPathInsideRoot(absolutePath, this.repoRoot)) {
+            fileSystemLogger.debug('Ignoring path outside repository root', { path: absolutePath });
+            return true;
+        }
+        let relativePath = path.relative(this.repoRoot, absolutePath);
+        if (!relativePath) {
+            return false;
+        }
+        const firstSegment = relativePath.split(path.sep)[0];
+        if (firstSegment === '.git') {
+            return true;
+        }
+        const isDirectory = isDirectorySafe(absolutePath);
+        if (isDirectory && !relativePath.endsWith(path.sep)) {
+            relativePath += path.sep;
+        }
+        const normalized = relativePath.split(path.sep).join('/');
+        for (const spec of this.ignoreSpecs) {
+            if (spec.matches(normalized)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getIgnoreSpecs() {
+        return [...this.ignoreSpecs];
+    }
+    reload() {
+        this.ignoreSpecs = [];
+        this.loadGitignoreFiles();
+    }
+    loadGitignoreFiles() {
+        const start = performance.now();
+        this.ignoreSpecs = [];
+        for (const gitignorePath of this.iterGitignoreFiles()) {
+            fileSystemLogger.debug('Processing .gitignore file', { path: gitignorePath });
+            const spec = this.createIgnoreSpec(gitignorePath);
+            if (spec) {
+                this.ignoreSpecs.push(spec);
+            }
+        }
+        const duration = performance.now() - start;
+        fileSystemLogger.debug('Loaded .gitignore specs', {
+            count: this.ignoreSpecs.length,
+            durationMs: Math.round(duration)
+        });
+    }
+    *iterGitignoreFiles() {
+        const queue = [this.repoRoot];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            if (current !== this.repoRoot) {
+                const relative = path.relative(this.repoRoot, current);
+                if (this.shouldIgnore(relative)) {
+                    continue;
+                }
+            }
+            let dirEntries;
+            try {
+                dirEntries = fs.readdirSync(current, { withFileTypes: true });
+            }
+            catch (error) {
+                if (isPermissionError(error)) {
+                    fileSystemLogger.debug('Skipping directory during gitignore discovery due to permission error', {
+                        path: current,
+                        error
+                    });
+                    continue;
+                }
+                throw error;
+            }
+            for (const entry of dirEntries) {
+                const entryPath = path.join(current, entry.name);
+                if (entry.isDirectory() || (entry.isSymbolicLink() && isDirectorySafe(entryPath))) {
+                    queue.push(entryPath);
+                    continue;
+                }
+                if (entry.isFile() && entry.name === '.gitignore') {
+                    yield entryPath;
+                }
+            }
+        }
+    }
+    createIgnoreSpec(gitignoreFilePath) {
+        let content;
+        try {
+            content = fs.readFileSync(gitignoreFilePath, 'utf-8');
+        }
+        catch (error) {
+            fileSystemLogger.debug('Failed to read .gitignore file', {
+                path: gitignoreFilePath,
+                error
+            });
+            return null;
+        }
+        const patterns = this.parseGitignoreContent(content, path.dirname(gitignoreFilePath));
+        if (patterns.length === 0) {
+            return null;
+        }
+        return new GitignoreSpec(gitignoreFilePath, patterns);
+    }
+    parseGitignoreContent(content, gitignoreDir) {
+        const patterns = [];
+        let relativeDir = path.relative(this.repoRoot, gitignoreDir);
+        if (relativeDir === '.') {
+            relativeDir = '';
+        }
+        for (const rawLine of content.split(/\r?\n/)) {
+            let line = stripTrailingWhitespace(rawLine);
+            if (!line || line.trimStart().startsWith('#')) {
+                continue;
+            }
+            let isNegation = false;
+            if (line.startsWith('!')) {
+                isNegation = true;
+                line = line.slice(1);
+            }
+            line = line.trim();
+            if (!line) {
+                continue;
+            }
+            if (line.startsWith('\\#') || line.startsWith('\\!')) {
+                line = line.slice(1);
+            }
+            const anchored = line.startsWith('/');
+            if (anchored) {
+                line = line.slice(1);
+            }
+            let adjustedPattern;
+            if (relativeDir) {
+                if (anchored) {
+                    adjustedPattern = path.join(relativeDir, line);
+                }
+                else if (line.startsWith('**/')) {
+                    adjustedPattern = path.join(relativeDir, line);
+                }
+                else {
+                    adjustedPattern = path.join(relativeDir, '**', line);
+                }
+            }
+            else if (anchored) {
+                adjustedPattern = `/${line}`;
+            }
+            else {
+                adjustedPattern = line;
+            }
+            if (isNegation) {
+                adjustedPattern = `!${adjustedPattern}`;
+            }
+            patterns.push(adjustedPattern.replace(/\\/g, '/'));
+        }
+        return patterns;
+    }
+}
+function normalizeCandidate(relativePath) {
+    let normalized = relativePath.replace(/\\/g, '/');
+    normalized = normalized.replace(/^\.\//, '');
+    if (normalized.startsWith('//')) {
+        normalized = normalized.slice(1);
+    }
+    return normalized;
+}
+function stripTrailingWhitespace(value) {
+    return value.replace(/[ \t]+$/, '');
+}
+function isDirectorySafe(candidatePath) {
+    try {
+        return fs.statSync(candidatePath).isDirectory();
+    }
+    catch (error) {
+        if (isPermissionError(error)) {
+            return false;
+        }
+        if (isErrno(error, 'ENOENT') || isErrno(error, 'ENOTDIR')) {
+            return false;
+        }
+        throw error;
+    }
+}
+function isPermissionError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const code = error.code;
+    return code === 'EACCES' || code === 'EPERM';
+}
+function isErrno(error, errno) {
+    return Boolean(error && typeof error === 'object' && error.code === errno);
+}
+function isPathInsideRoot(absolutePath, root) {
+    const normalizedRoot = path.resolve(root);
+    const normalizedPath = path.resolve(absolutePath);
+    return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}${path.sep}`);
+}
+export function matchPath(relativePath, matcher, rootPath = '') {
+    let normalized = String(relativePath).replace(/\\/g, '/');
+    if (!normalized.startsWith('/')) {
+        normalized = `/${normalized}`;
+    }
+    const absolutePath = rootPath
+        ? path.resolve(rootPath, relativePath)
+        : path.resolve(relativePath);
+    if (isDirectorySafe(absolutePath) && !normalized.endsWith('/')) {
+        normalized = `${normalized}/`;
+    }
+    const withoutLeadingSlash = normalized.slice(1);
+    const candidates = new Set();
+    if (withoutLeadingSlash) {
+        candidates.add(withoutLeadingSlash);
+    }
+    if (withoutLeadingSlash.endsWith('/')) {
+        const withoutTrailing = withoutLeadingSlash.slice(0, -1);
+        if (withoutTrailing) {
+            candidates.add(withoutTrailing);
+        }
+    }
+    else if (withoutLeadingSlash) {
+        candidates.add(`${withoutLeadingSlash}/`);
+    }
+    for (const candidate of candidates) {
+        if (matcher.ignores(candidate)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/serena/util/general.d.ts

@@ -0,0 +1,11 @@
+interface MinimalYamlDocument {
+    toString(): string;
+    set?(key: string, value: unknown): void;
+    toJSON?(): unknown;
+    [key: string]: unknown;
+}
+export type YamlObject = Record<string, unknown>;
+export type YamlDocument = MinimalYamlDocument;
+export declare function loadYaml(pathname: string, preserveComments?: boolean): YamlObject | YamlDocument;
+export declare function saveYaml(pathname: string, data: YamlObject | YamlDocument, preserveComments?: boolean): void;
+export {};