@nogataka/smart-edit 0.0.14

package/dist/serena/util/general.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+let cachedYamlModule;
+function loadYamlModule() {
+    if (cachedYamlModule) {
+        return cachedYamlModule;
+    }
+    try {
+        const module = require('yaml');
+        cachedYamlModule = module;
+        return module;
+    }
+    catch {
+        throw new Error('YAML サポートが利用できません。依存パッケージ "yaml" をインストールしてください。');
+    }
+}
+export function loadYaml(pathname, preserveComments = false) {
+    const yaml = loadYamlModule();
+    const source = fs.readFileSync(pathname, 'utf-8');
+    if (preserveComments) {
+        return yaml.parseDocument(source);
+    }
+    const parsed = yaml.parse(source);
+    if (parsed && typeof parsed === 'object') {
+        return parsed;
+    }
+    return {};
+}
+export function saveYaml(pathname, data, preserveComments = false) {
+    const yaml = loadYamlModule();
+    const directory = path.dirname(pathname);
+    fs.mkdirSync(directory, { recursive: true });
+    const serialized = preserveComments && isYamlDocument(data)
+        ? data.toString()
+        : yaml.stringify(data);
+    fs.writeFileSync(pathname, serialized, 'utf-8');
+}
+function isYamlDocument(data) {
+    return typeof data === 'object' && data !== null && typeof data.toString === 'function';
+}

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

@@ -0,0 +1,11 @@
+export interface GitStatus {
+    commit: string;
+    hasUnstagedChanges: boolean;
+    hasStagedUncommittedChanges: boolean;
+    hasUntrackedFiles: boolean;
+}
+export interface GetGitStatusOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function getGitStatus(options?: GetGitStatusOptions): Promise<GitStatus | null>;

package/dist/serena/util/git.js

@@ -0,0 +1,37 @@
+import { createSerenaLogger } from './logging.js';
+import { subprocessCheckOutput } from './shell.js';
+const { logger: gitLogger } = createSerenaLogger({
+    level: 'debug',
+    emitToConsole: false,
+    name: 'SerenaGit'
+});
+export async function getGitStatus(options = {}) {
+    try {
+        const commitHash = await runGitCommand(['rev-parse', 'HEAD'], options);
+        const hasUnstagedChanges = await hasGitOutput(['diff', '--name-only'], options);
+        const hasStagedUncommittedChanges = await hasGitOutput(['diff', '--staged', '--name-only'], options);
+        const hasUntrackedFiles = await hasGitOutput(['ls-files', '--others', '--exclude-standard'], options);
+        return {
+            commit: commitHash,
+            hasUnstagedChanges,
+            hasStagedUncommittedChanges,
+            hasUntrackedFiles
+        };
+    }
+    catch (error) {
+        gitLogger.debug('Failed to read git status', { error });
+        return null;
+    }
+}
+async function runGitCommand(args, { cwd, env }) {
+    const output = await subprocessCheckOutput(['git', ...args], {
+        cwd,
+        env,
+        strip: true
+    });
+    return output;
+}
+async function hasGitOutput(args, options) {
+    const output = await runGitCommand(args, options);
+    return output.length > 0;
+}

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

@@ -0,0 +1,45 @@
+export type Constructor<T = unknown> = abstract new (...args: unknown[]) => T;
+export interface RegisterSubclassOptions {
+    /**
+     * 任意で明示的な基底クラスを指定できます。指定しない場合は prototype 連鎖から推測します。
+     */
+    base?: Constructor<unknown>;
+}
+/**
+ * サブクラスをレジストリに登録します。TypeScript では Python のように __subclasses__() が無いため、
+ * 各クラス定義側からこの関数を呼び出して静的メタデータを構築します。
+ */
+export declare function registerSubclass<T>(derived: Constructor<T>, options?: RegisterSubclassOptions): void;
+/**
+ * 指定した基底クラスのサブクラスを列挙します。recursive = true の場合は再帰的に辿ります。
+ */
+export declare function iterSubclasses<T>(base: Constructor<T>, recursive?: boolean): Generator<Constructor<T>, void, unknown>;
+/**
+ * テスト用途などでレジストリを初期化したい場合に使用します。
+ */
+export declare function clearSubclassRegistry(): void;
+export interface FilenameMatcher {
+    isRelevantFilename(filename: string): boolean;
+}
+export interface ProgrammingLanguageDefinition {
+    name: string;
+    matcher: FilenameMatcher;
+    experimental?: boolean;
+}
+export interface DetermineLanguageOptions {
+    languages?: Iterable<LanguageInput>;
+    includeExperimental?: boolean;
+}
+type LanguageInput = ProgrammingLanguageDefinition | SolidLanguageLike;
+interface SolidLanguageLike {
+    toString(): string;
+    getSourceFnMatcher?: () => unknown;
+    getSourceFilenameMatcher?: () => unknown;
+    isExperimental?: () => boolean;
+}
+export declare function registerLanguageDefinition(language: ProgrammingLanguageDefinition): void;
+export declare function registerLanguageDefinitions(languages: Iterable<ProgrammingLanguageDefinition>): void;
+export declare function clearLanguageRegistry(): void;
+export declare function getRegisteredLanguages(): ProgrammingLanguageDefinition[];
+export declare function determineProgrammingLanguageComposition(repoPath: string, options?: DetermineLanguageOptions): Record<string, number>;
+export {};

package/dist/serena/util/inspection.js

@@ -0,0 +1,221 @@
+import path from 'node:path';
+import { findAllNonIgnoredFiles } from './file_system.js';
+const subclassRegistry = new Map();
+/**
+ * サブクラスをレジストリに登録します。TypeScript では Python のように __subclasses__() が無いため、
+ * 各クラス定義側からこの関数を呼び出して静的メタデータを構築します。
+ */
+export function registerSubclass(derived, options) {
+    const base = options?.base ?? getDirectBaseConstructor(derived);
+    if (!base || base === derived) {
+        return;
+    }
+    let entries = subclassRegistry.get(base);
+    if (!entries) {
+        entries = new Set();
+        subclassRegistry.set(base, entries);
+    }
+    entries.add(derived);
+}
+/**
+ * 指定した基底クラスのサブクラスを列挙します。recursive = true の場合は再帰的に辿ります。
+ */
+export function* iterSubclasses(base, recursive = true) {
+    yield* iterateSubclassesInternal(base, recursive, new Set());
+}
+function* iterateSubclassesInternal(base, recursive, seen) {
+    const direct = subclassRegistry.get(base);
+    if (!direct) {
+        return;
+    }
+    for (const subclass of direct) {
+        if (seen.has(subclass)) {
+            continue;
+        }
+        seen.add(subclass);
+        yield subclass;
+        if (recursive) {
+            yield* iterateSubclassesInternal(subclass, true, seen);
+        }
+    }
+}
+function getDirectBaseConstructor(ctor) {
+    const prototype = Object.getPrototypeOf(ctor.prototype);
+    if (!prototype) {
+        return undefined;
+    }
+    const parentCtor = prototype.constructor;
+    if (typeof parentCtor !== 'function') {
+        return undefined;
+    }
+    if (parentCtor === Object || parentCtor === Function) {
+        return undefined;
+    }
+    return parentCtor;
+}
+/**
+ * テスト用途などでレジストリを初期化したい場合に使用します。
+ */
+export function clearSubclassRegistry() {
+    subclassRegistry.clear();
+}
+const languageRegistry = new Map();
+export function registerLanguageDefinition(language) {
+    const matcherFn = bindMatcher(language.matcher);
+    languageRegistry.set(language.name, {
+        name: language.name,
+        matcher: {
+            isRelevantFilename: matcherFn
+        },
+        experimental: language.experimental ?? false
+    });
+}
+export function registerLanguageDefinitions(languages) {
+    for (const language of languages) {
+        registerLanguageDefinition(language);
+    }
+}
+export function clearLanguageRegistry() {
+    languageRegistry.clear();
+}
+export function getRegisteredLanguages() {
+    return Array.from(languageRegistry.values()).map((language) => ({
+        name: language.name,
+        matcher: bindMatcherObject(language.matcher),
+        experimental: language.experimental ?? false
+    }));
+}
+export function determineProgrammingLanguageComposition(repoPath, options) {
+    const files = findAllNonIgnoredFiles(repoPath);
+    if (files.length === 0) {
+        return {};
+    }
+    const includeExperimental = options?.includeExperimental ?? false;
+    const languages = resolveLanguages(options?.languages, includeExperimental);
+    if (!languages.length) {
+        return {};
+    }
+    const totalFiles = files.length;
+    const counts = new Map();
+    for (const language of languages) {
+        let count = 0;
+        for (const filePath of files) {
+            const filename = path.basename(filePath);
+            if (language.matcher.isRelevantFilename(filename)) {
+                count += 1;
+            }
+        }
+        if (count > 0) {
+            counts.set(language.name, count);
+        }
+    }
+    const result = {};
+    for (const [name, count] of counts) {
+        const percentage = (count / totalFiles) * 100;
+        result[name] = Math.round(percentage * 100) / 100;
+    }
+    return result;
+}
+function resolveLanguages(explicit, includeExperimental) {
+    const source = explicit ?? languageRegistry.values();
+    const normalized = new Map();
+    for (const item of source) {
+        const definition = normalizeLanguageInput(item, includeExperimental);
+        if (definition) {
+            normalized.set(definition.name, definition);
+        }
+    }
+    return Array.from(normalized.values());
+}
+function normalizeLanguageInput(input, includeExperimental) {
+    if (isProgrammingLanguageDefinition(input)) {
+        if (!includeExperimental && input.experimental) {
+            return undefined;
+        }
+        const matcher = bindMatcher(input.matcher);
+        return {
+            name: input.name,
+            matcher: {
+                isRelevantFilename: matcher
+            },
+            experimental: input.experimental ?? false
+        };
+    }
+    if (isSolidLanguageLike(input)) {
+        const experimental = typeof input.isExperimental === 'function' ? input.isExperimental() : false;
+        if (!includeExperimental && experimental) {
+            return undefined;
+        }
+        const matcherCandidate = typeof input.getSourceFnMatcher === 'function'
+            ? input.getSourceFnMatcher()
+            : typeof input.getSourceFilenameMatcher === 'function'
+                ? input.getSourceFilenameMatcher()
+                : undefined;
+        if (!matcherCandidate) {
+            throw new TypeError('Language object does not expose a source filename matcher');
+        }
+        const matcher = bindMatcher(normalizeMatcher(matcherCandidate));
+        return {
+            name: String(input),
+            matcher: {
+                isRelevantFilename: matcher
+            },
+            experimental
+        };
+    }
+    throw new TypeError('Unsupported language definition encountered');
+}
+function bindMatcherObject(matcher) {
+    const bound = bindMatcher(matcher);
+    return {
+        isRelevantFilename: bound
+    };
+}
+function bindMatcher(matcher) {
+    if (typeof matcher.isRelevantFilename !== 'function') {
+        return () => false;
+    }
+    return matcher.isRelevantFilename.bind(matcher);
+}
+function normalizeMatcher(candidate) {
+    if (isFilenameMatcher(candidate)) {
+        return candidate;
+    }
+    if (candidate && typeof candidate === 'object') {
+        const recordCandidate = candidate;
+        const maybeCamel = recordCandidate.isRelevantFilename;
+        if (typeof maybeCamel === 'function') {
+            return {
+                isRelevantFilename: maybeCamel.bind(candidate)
+            };
+        }
+        const maybeSnake = recordCandidate.is_relevant_filename;
+        if (typeof maybeSnake === 'function') {
+            return {
+                isRelevantFilename: maybeSnake.bind(candidate)
+            };
+        }
+    }
+    throw new TypeError('Unsupported filename matcher');
+}
+function isProgrammingLanguageDefinition(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.name === 'string' &&
+        typeof candidate.matcher === 'object' &&
+        candidate.matcher !== null &&
+        typeof candidate.matcher.isRelevantFilename === 'function');
+}
+function isSolidLanguageLike(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.toString === 'function' &&
+        (typeof candidate.getSourceFnMatcher === 'function' || typeof candidate.getSourceFilenameMatcher === 'function'));
+}
+function isFilenameMatcher(value) {
+    return !!value && typeof value === 'object' && typeof value.isRelevantFilename === 'function';
+}

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

@@ -0,0 +1,46 @@
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export interface SerenaLogger {
+    trace(message: string, meta?: unknown): void;
+    debug(message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+    fatal(message: string, meta?: unknown): void;
+}
+export interface SerenaLoggerOptions {
+    level?: LogLevel;
+    memoryHandler?: MemoryLogHandler;
+    emitToConsole?: boolean;
+    name?: string;
+}
+export declare function setConsoleLoggingEnabled(enabled: boolean): void;
+export declare function isConsoleLoggingEnabled(): boolean;
+export interface SerenaLogMessage {
+    timestamp: Date;
+    level: LogLevel;
+    message: string;
+    meta?: unknown;
+    loggerName: string;
+}
+export declare class LogBuffer {
+    private readonly logMessages;
+    append(message: string): void;
+    getLogMessages(): string[];
+}
+export type EmitCallback = (message: string) => void;
+export declare class MemoryLogHandler {
+    private readonly buffer;
+    private readonly callbacks;
+    private queue;
+    private draining;
+    addEmitCallback(callback: EmitCallback): void;
+    removeEmitCallback(callback: EmitCallback): void;
+    handle(message: string): void;
+    getLogMessages(): string[];
+    private flush;
+}
+export declare function createSerenaLogger(options?: SerenaLoggerOptions): {
+    logger: SerenaLogger;
+    memoryHandler: MemoryLogHandler;
+};
+export declare function formatLogMessage(message: SerenaLogMessage): string;

package/dist/serena/util/logging.js

@@ -0,0 +1,205 @@
+import { setImmediate } from 'node:timers';
+import { SERENA_LOG_FORMAT } from '../constants.js';
+const LEVEL_ORDER = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60
+};
+let consoleLoggingEnabled = true;
+export function setConsoleLoggingEnabled(enabled) {
+    consoleLoggingEnabled = enabled;
+}
+export function isConsoleLoggingEnabled() {
+    return consoleLoggingEnabled;
+}
+export class LogBuffer {
+    logMessages = [];
+    append(message) {
+        this.logMessages.push(message);
+    }
+    getLogMessages() {
+        return [...this.logMessages];
+    }
+}
+export class MemoryLogHandler {
+    buffer = new LogBuffer();
+    callbacks = new Set();
+    queue = [];
+    draining = false;
+    addEmitCallback(callback) {
+        this.callbacks.add(callback);
+    }
+    removeEmitCallback(callback) {
+        this.callbacks.delete(callback);
+    }
+    handle(message) {
+        this.queue.push(message);
+        if (!this.draining) {
+            this.draining = true;
+            setImmediate(() => this.flush());
+        }
+    }
+    getLogMessages() {
+        return this.buffer.getLogMessages();
+    }
+    flush() {
+        while (this.queue.length > 0) {
+            const message = this.queue.shift();
+            if (message === undefined) {
+                continue;
+            }
+            this.buffer.append(message);
+            for (const callback of this.callbacks) {
+                try {
+                    callback(message);
+                }
+                catch {
+                    // ignore listener errors to avoid breaking logging pipeline
+                }
+            }
+        }
+        this.draining = false;
+    }
+}
+class SerenaConsoleLogger {
+    level;
+    emitToConsole;
+    memoryHandler;
+    loggerName;
+    constructor(options) {
+        this.level = options.level;
+        this.emitToConsole = options.emitToConsole;
+        this.memoryHandler = options.memoryHandler;
+        this.loggerName = options.name ?? 'SerenaLogger';
+    }
+    trace(message, meta) {
+        this.log('trace', message, meta);
+    }
+    debug(message, meta) {
+        this.log('debug', message, meta);
+    }
+    info(message, meta) {
+        this.log('info', message, meta);
+    }
+    warn(message, meta) {
+        this.log('warn', message, meta);
+    }
+    error(message, meta) {
+        this.log('error', message, meta);
+    }
+    fatal(message, meta) {
+        this.log('fatal', message, meta);
+    }
+    setMemoryHandler(memoryHandler) {
+        this.memoryHandler = memoryHandler;
+    }
+    log(level, message, meta) {
+        if (LEVEL_ORDER[level] < LEVEL_ORDER[this.level]) {
+            return;
+        }
+        const formatted = formatLogMessage({
+            timestamp: new Date(),
+            level,
+            message,
+            meta,
+            loggerName: this.loggerName
+        });
+        this.memoryHandler?.handle(formatted);
+        if (!this.emitToConsole || !consoleLoggingEnabled) {
+            return;
+        }
+        const consoleMessage = meta instanceof Error && meta.stack
+            ? `${formatted}\n${meta.stack}`
+            : formatted;
+        switch (level) {
+            case 'trace':
+                console.trace(consoleMessage);
+                break;
+            case 'debug':
+                console.debug(consoleMessage);
+                break;
+            case 'info':
+                console.info(consoleMessage);
+                break;
+            case 'warn':
+                console.warn(consoleMessage);
+                break;
+            case 'error':
+            case 'fatal':
+                console.error(consoleMessage);
+                break;
+            default:
+                console.log(consoleMessage);
+        }
+    }
+}
+const sharedLoggers = new Set();
+let sharedMemoryHandler = null;
+function getOrCreateSharedMemoryHandler() {
+    sharedMemoryHandler ??= new MemoryLogHandler();
+    return sharedMemoryHandler;
+}
+export function createSerenaLogger(options = {}) {
+    const useSharedHandler = options.memoryHandler === undefined;
+    const memoryHandler = useSharedHandler ? getOrCreateSharedMemoryHandler() : options.memoryHandler;
+    const emitToConsole = (options.emitToConsole ?? true) && consoleLoggingEnabled;
+    const loggerInstance = new SerenaConsoleLogger({
+        level: options.level ?? 'info',
+        emitToConsole,
+        memoryHandler,
+        name: options.name
+    });
+    if (useSharedHandler) {
+        sharedLoggers.add(loggerInstance);
+    }
+    return { logger: loggerInstance, memoryHandler };
+}
+export function formatLogMessage(message) {
+    const level = message.level.toUpperCase().padEnd(5).slice(0, 5);
+    const timestamp = message.timestamp.toISOString().replace('T', ' ').replace('Z', '');
+    const threadName = 'main';
+    const location = `${message.loggerName}:log`;
+    let formatted = SERENA_LOG_FORMAT.replace('%(levelname)-5s', level)
+        .replace('%(asctime)-15s', timestamp.padEnd(15).slice(0, 15))
+        .replace('%(threadName)s', threadName)
+        .replace('%(name)s', message.loggerName)
+        .replace('%(funcName)s', 'log')
+        .replace('%(lineno)d', '0')
+        .replace('%(message)s', enrichMessage(message.message, message.meta));
+    if (!SERENA_LOG_FORMAT.includes('%(name)s:%(funcName)s:%(lineno)d')) {
+        formatted = `${level} ${timestamp} [${threadName}] ${location} - ${enrichMessage(message.message, message.meta)}`;
+    }
+    return formatted;
+}
+function enrichMessage(message, meta) {
+    if (meta === undefined || meta === null) {
+        return message;
+    }
+    if (meta instanceof Error) {
+        return `${message} | error=${meta.message}`;
+    }
+    if (typeof meta === 'object') {
+        try {
+            return `${message} | ${JSON.stringify(meta)}`;
+        }
+        catch {
+            return `${message} | [unserializable meta]`;
+        }
+    }
+    if (typeof meta === 'string') {
+        return `${message} | ${meta}`;
+    }
+    if (typeof meta === 'number' || typeof meta === 'boolean' || typeof meta === 'bigint') {
+        return `${message} | ${meta.toString()}`;
+    }
+    if (typeof meta === 'symbol') {
+        return `${message} | ${meta.toString()}`;
+    }
+    if (typeof meta === 'function') {
+        return `${message} | [function]`;
+    }
+    return message;
+}

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

@@ -0,0 +1,21 @@
+export interface ShellCommandResult {
+    stdout: string;
+    stderr?: string;
+    returnCode: number;
+    cwd: string;
+    signal?: NodeJS.Signals;
+}
+export interface ExecuteShellCommandOptions {
+    cwd?: string;
+    captureStderr?: boolean;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function executeShellCommand(command: string, { cwd, captureStderr, env }?: ExecuteShellCommandOptions): Promise<ShellCommandResult>;
+export interface SubprocessCheckOutputOptions {
+    encoding?: BufferEncoding;
+    strip?: boolean;
+    timeoutMs?: number;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function subprocessCheckOutput(args: string[], { encoding, strip, timeoutMs, cwd, env }?: SubprocessCheckOutputOptions): Promise<string>;