@nogataka/smart-edit 0.0.14

package/dist/solidlsp/ls_request.d.ts

@@ -0,0 +1,31 @@
+import type { DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams, DocumentSymbolResult, DocumentSymbolsOptions, FullSymbolTreeOptions, ReferenceInSymbol, ReferencingSymbolsOptions, SolidLanguageServerHandler, SolidLanguageServerNotifications, SolidLanguageServerRequests, UnifiedSymbolInformation } from './ls.js';
+export interface DocumentSymbolRequestParams {
+    textDocument: {
+        uri: string;
+    };
+    options?: DocumentSymbolsOptions;
+}
+export interface LanguageServerRequestDelegate {
+    sendRequest(method: string, params?: unknown): unknown;
+}
+export declare class LanguageServerRequest implements SolidLanguageServerRequests {
+    private readonly delegate;
+    constructor(handler: LanguageServerRequestDelegate);
+    documentSymbol(params: DocumentSymbolRequestParams): DocumentSymbolResult | null;
+    fullSymbolTree(params: FullSymbolTreeOptions): UnifiedSymbolInformation[] | null;
+    referencingSymbols(params: ReferencingSymbolsOptions): ReferenceInSymbol[] | null;
+    overview(relativeFilePath: string): Record<string, UnifiedSymbolInformation[]> | null;
+    shutdown(): void;
+}
+export declare class LspNotification implements SolidLanguageServerNotifications {
+    private readonly send;
+    constructor(sender: (method: string, params?: unknown) => void);
+    initialized(params?: unknown): void;
+    exit(): void;
+    didOpenTextDocument(params: DidOpenTextDocumentParams): void;
+    didChangeTextDocument(params: DidChangeTextDocumentParams): void;
+    didCloseTextDocument(params: DidCloseTextDocumentParams): void;
+}
+export type SolidLanguageServerHandlerLike = SolidLanguageServerHandler & {
+    sendRequest(method: string, params?: unknown): unknown;
+};

package/dist/solidlsp/ls_request.js

@@ -0,0 +1,42 @@
+export class LanguageServerRequest {
+    delegate;
+    constructor(handler) {
+        this.delegate = handler;
+    }
+    documentSymbol(params) {
+        return this.delegate.sendRequest('textDocument/documentSymbol', params);
+    }
+    fullSymbolTree(params) {
+        return this.delegate.sendRequest('serena/fullSymbolTree', params);
+    }
+    referencingSymbols(params) {
+        return this.delegate.sendRequest('serena/referencingSymbols', params);
+    }
+    overview(relativeFilePath) {
+        return this.delegate.sendRequest('serena/overview', relativeFilePath);
+    }
+    shutdown() {
+        void this.delegate.sendRequest('shutdown');
+    }
+}
+export class LspNotification {
+    send;
+    constructor(sender) {
+        this.send = sender;
+    }
+    initialized(params = null) {
+        this.send('initialized', params);
+    }
+    exit() {
+        this.send('exit');
+    }
+    didOpenTextDocument(params) {
+        this.send('textDocument/didOpen', params ?? null);
+    }
+    didChangeTextDocument(params) {
+        this.send('textDocument/didChange', params ?? null);
+    }
+    didCloseTextDocument(params) {
+        this.send('textDocument/didClose', params ?? null);
+    }
+}

package/dist/solidlsp/ls_types.d.ts

@@ -0,0 +1,7 @@
+export declare enum ErrorCodes {
+    ParseError = -32700,
+    InvalidRequest = -32600,
+    MethodNotFound = -32601,
+    InvalidParams = -32602,
+    InternalError = -32603
+}

package/dist/solidlsp/ls_types.js

@@ -0,0 +1,8 @@
+export var ErrorCodes;
+(function (ErrorCodes) {
+    ErrorCodes[ErrorCodes["ParseError"] = -32700] = "ParseError";
+    ErrorCodes[ErrorCodes["InvalidRequest"] = -32600] = "InvalidRequest";
+    ErrorCodes[ErrorCodes["MethodNotFound"] = -32601] = "MethodNotFound";
+    ErrorCodes[ErrorCodes["InvalidParams"] = -32602] = "InvalidParams";
+    ErrorCodes[ErrorCodes["InternalError"] = -32603] = "InternalError";
+})(ErrorCodes || (ErrorCodes = {}));

package/dist/solidlsp/lsp_protocol_handler/server.d.ts

@@ -0,0 +1,61 @@
+import { Buffer } from 'node:buffer';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type JsonArray = JsonValue[];
+export type StringDict = Record<string, JsonValue>;
+export type PayloadLike = StringDict | JsonArray | null;
+export declare const ENCODING = "utf-8";
+export interface ProcessLaunchInfo {
+    /** Command to launch the language server process. */
+    cmd: string | string[];
+    /** Additional environment variables to inject when spawning the process. */
+    env?: Record<string, string>;
+    /** Working directory for the spawned process. Defaults to the current process CWD. */
+    cwd?: string;
+}
+export declare class LSPError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+    toLsp(): {
+        code: number;
+        message: string;
+        data?: JsonValue;
+    };
+    static fromLsp(payload: {
+        code?: JsonValue;
+        message?: JsonValue;
+    }): LSPError;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: JsonValue;
+    error?: {
+        code: number;
+        message: string;
+        data?: JsonValue;
+    };
+}
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: number | string | null;
+    method: string;
+    params?: PayloadLike;
+}
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse;
+export declare function makeResponse(requestId: number | string | null, params: PayloadLike): JsonRpcResponse;
+export declare function makeErrorResponse(requestId: number | string | null, err: LSPError): JsonRpcResponse;
+export declare function makeNotification(method: string, params: PayloadLike): JsonRpcRequest;
+export declare function makeRequest(method: string, requestId: number | string, params: PayloadLike): JsonRpcRequest;
+export declare function createMessage(payload: JsonRpcMessage): Buffer;
+export declare enum MessageType {
+    error = 1,
+    warning = 2,
+    info = 3,
+    log = 4
+}
+export declare function contentLength(line: Buffer): number | null;
+export declare function defaultCwd(): string;

package/dist/solidlsp/lsp_protocol_handler/server.js

@@ -0,0 +1,68 @@
+import { Buffer } from 'node:buffer';
+import os from 'node:os';
+export const ENCODING = 'utf-8';
+export class LSPError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'LSPError';
+        this.code = code;
+    }
+    toLsp() {
+        return { code: this.code, message: this.message };
+    }
+    static fromLsp(payload) {
+        const code = typeof payload.code === 'number' ? payload.code : -32603;
+        const message = typeof payload.message === 'string' ? payload.message : 'Unknown LSP error';
+        return new LSPError(code, message);
+    }
+}
+export function makeResponse(requestId, params) {
+    return { jsonrpc: '2.0', id: requestId, result: params ?? null };
+}
+export function makeErrorResponse(requestId, err) {
+    return { jsonrpc: '2.0', id: requestId, error: err.toLsp() };
+}
+export function makeNotification(method, params) {
+    const payload = { jsonrpc: '2.0', method };
+    if (params !== undefined) {
+        payload.params = params;
+    }
+    return payload;
+}
+export function makeRequest(method, requestId, params) {
+    const payload = { jsonrpc: '2.0', method, id: requestId };
+    if (params !== undefined) {
+        payload.params = params;
+    }
+    return payload;
+}
+export function createMessage(payload) {
+    const body = Buffer.from(JSON.stringify(payload), ENCODING);
+    const header = Buffer.from(`Content-Length: ${body.byteLength}\r\nContent-Type: application/vscode-jsonrpc; charset=${ENCODING}\r\n\r\n`, ENCODING);
+    return Buffer.concat([header, body]);
+}
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["error"] = 1] = "error";
+    MessageType[MessageType["warning"] = 2] = "warning";
+    MessageType[MessageType["info"] = 3] = "info";
+    MessageType[MessageType["log"] = 4] = "log";
+})(MessageType || (MessageType = {}));
+export function contentLength(line) {
+    // Content-Length header is case insensitive per RFC7230.
+    const normalized = line.toString(ENCODING).trim();
+    const prefix = 'content-length:';
+    if (!normalized.toLowerCase().startsWith(prefix)) {
+        return null;
+    }
+    const value = normalized.slice(prefix.length).trim();
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Invalid Content-Length header: ${value}`);
+    }
+    return parsed;
+}
+export function defaultCwd() {
+    return process.cwd?.() ?? os.homedir();
+}

package/dist/solidlsp/util/subprocess_util.d.ts

@@ -0,0 +1,6 @@
+import type { SpawnOptions, SpawnSyncOptions } from 'node:child_process';
+export type PlatformSubprocessOptions = (SpawnOptions | SpawnSyncOptions) & {
+    windowsHide?: boolean;
+};
+export declare function defaultSubprocessOptions(platform?: NodeJS.Platform): PlatformSubprocessOptions;
+export declare function ensureDefaultSubprocessOptions<T extends PlatformSubprocessOptions>(options: T, platform?: NodeJS.Platform): T;

package/dist/solidlsp/util/subprocess_util.js

@@ -0,0 +1,11 @@
+import process from 'node:process';
+export function defaultSubprocessOptions(platform = process.platform) {
+    return platform === 'win32' ? { windowsHide: true } : {};
+}
+export function ensureDefaultSubprocessOptions(options, platform = process.platform) {
+    const defaults = defaultSubprocessOptions(platform);
+    if (defaults.windowsHide && options.windowsHide === undefined) {
+        options.windowsHide = defaults.windowsHide;
+    }
+    return options;
+}

package/dist/solidlsp/util/zip.d.ts

@@ -0,0 +1,25 @@
+export interface SafeZipExtractorOptions {
+    verbose?: boolean;
+    includePatterns?: string[];
+    excludePatterns?: string[];
+    logger?: ZipLogger;
+}
+export interface ZipLogger {
+    info(message: string): void;
+    error(message: string, error?: unknown): void;
+}
+export declare class SafeZipExtractor {
+    private readonly archivePath;
+    private readonly extractDir;
+    private readonly verbose;
+    private readonly includePatterns;
+    private readonly excludePatterns;
+    private readonly logger?;
+    constructor(archivePath: string, extractDir: string, options?: SafeZipExtractorOptions);
+    extractAll(): void;
+    protected shouldExtract(filename: string): boolean;
+    protected resolveTargetPath(filename: string): string | null;
+    protected normalizePath(targetPath: string): string;
+    private logInfo;
+    private logError;
+}

package/dist/solidlsp/util/zip.js

@@ -0,0 +1,188 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import AdmZip from 'adm-zip';
+export class SafeZipExtractor {
+    archivePath;
+    extractDir;
+    verbose;
+    includePatterns;
+    excludePatterns;
+    logger;
+    constructor(archivePath, extractDir, options = {}) {
+        this.archivePath = path.resolve(archivePath);
+        this.extractDir = path.resolve(extractDir);
+        this.verbose = options.verbose ?? true;
+        this.includePatterns = options.includePatterns ?? [];
+        this.excludePatterns = options.excludePatterns ?? [];
+        this.logger = options.logger;
+    }
+    extractAll() {
+        if (!fs.existsSync(this.archivePath)) {
+            throw new Error(`Archive not found: ${this.archivePath}`);
+        }
+        if (this.verbose) {
+            this.logInfo(`Extracting from: ${this.archivePath} to ${this.extractDir}`);
+        }
+        const zip = new AdmZip(this.archivePath);
+        for (const entry of zip.getEntries()) {
+            const filename = entry.entryName;
+            if (!this.shouldExtract(filename)) {
+                if (this.verbose) {
+                    this.logInfo(`Skipped: ${filename}`);
+                }
+                continue;
+            }
+            try {
+                const outputPath = this.resolveTargetPath(filename);
+                if (!outputPath) {
+                    if (this.verbose) {
+                        this.logInfo(`Skipping outside-path entry: ${filename}`);
+                    }
+                    continue;
+                }
+                if (entry.isDirectory) {
+                    fs.mkdirSync(outputPath, { recursive: true });
+                    continue;
+                }
+                const directory = path.dirname(outputPath);
+                fs.mkdirSync(directory, { recursive: true });
+                const finalPath = this.normalizePath(outputPath);
+                const data = entry.getData();
+                fs.writeFileSync(finalPath, data);
+                if (this.verbose) {
+                    this.logInfo(`Extracted: ${filename}`);
+                }
+            }
+            catch (error) {
+                this.logError(`Failed to extract ${filename}`, error);
+            }
+        }
+    }
+    shouldExtract(filename) {
+        if (this.includePatterns.length > 0 && !this.includePatterns.some((pattern) => matchesGlob(filename, pattern))) {
+            return false;
+        }
+        if (this.excludePatterns.length > 0 && this.excludePatterns.some((pattern) => matchesGlob(filename, pattern))) {
+            return false;
+        }
+        return true;
+    }
+    resolveTargetPath(filename) {
+        const sanitized = filename.replace(/^\/+/, '');
+        const target = path.resolve(this.extractDir, sanitized);
+        const relative = path.relative(this.extractDir, target);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+            return null;
+        }
+        return target;
+    }
+    normalizePath(targetPath) {
+        if (process.platform === 'win32') {
+            const absolute = path.resolve(targetPath);
+            if (!absolute.startsWith('\\\\?\\')) {
+                return `\\\\?\\${absolute}`;
+            }
+            return absolute;
+        }
+        return targetPath;
+    }
+    logInfo(message) {
+        if (this.logger) {
+            this.logger.info(message);
+        }
+        else {
+            console.info(message);
+        }
+    }
+    logError(message, error) {
+        if (this.logger) {
+            this.logger.error(message, error);
+            return;
+        }
+        console.error(`${message}:`, error);
+    }
+}
+function matchesGlob(filename, pattern) {
+    const regex = globToRegExp(pattern);
+    return regex.test(filename);
+}
+function globToRegExp(pattern) {
+    let regex = '^';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const char = pattern[i];
+        if (char === '*') {
+            regex += '.*';
+            continue;
+        }
+        if (char === '?') {
+            regex += '.';
+            continue;
+        }
+        if (char === '[') {
+            const { expression, length } = convertCharacterClass(pattern, i);
+            regex += expression;
+            i += length;
+            continue;
+        }
+        regex += escapeRegexChar(char);
+    }
+    regex += '$';
+    return new RegExp(regex);
+}
+function convertCharacterClass(pattern, startIndex) {
+    let index = startIndex + 1;
+    let negate = false;
+    if (index >= pattern.length) {
+        return { expression: '\\[', length: 0 };
+    }
+    let firstChar = pattern[index];
+    if (firstChar === '!' || firstChar === '^') {
+        negate = true;
+        index += 1;
+        firstChar = pattern[index];
+    }
+    if (index >= pattern.length) {
+        return { expression: '\\[', length: 0 };
+    }
+    const classChars = [];
+    let closed = false;
+    if (firstChar === ']') {
+        classChars.push('\\]');
+        index += 1;
+    }
+    for (; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === ']') {
+            closed = true;
+            break;
+        }
+        if (char === '\\' && index + 1 < pattern.length) {
+            index += 1;
+            classChars.push(escapeClassChar(pattern[index]));
+            continue;
+        }
+        classChars.push(escapeClassChar(char));
+    }
+    if (!closed) {
+        return { expression: '\\[', length: 0 };
+    }
+    const expression = `[${negate ? '^' : ''}${classChars.join('')}]`;
+    const consumedLength = index - startIndex;
+    return { expression, length: consumedLength };
+}
+function escapeRegexChar(char) {
+    if (/[[\]{}()*+?.\\^$|]/.test(char)) {
+        return `\\${char}`;
+    }
+    return char;
+}
+function escapeClassChar(char) {
+    if (char === '-') {
+        return '-';
+    }
+    if (char === '^' || char === ']' || char === '\\') {
+        return `\\${char}`;
+    }
+    return char;
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@nogataka/smart-edit",
+  "version": "0.0.14",
+  "description": "TypeScript版 Serena",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=20.11.0"
+  },
+  "bin": {
+    "smart-edit": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@dqbd/tiktoken": "^1.0.22",
+    "@modelcontextprotocol/sdk": "^1.16.0",
+    "adm-zip": "^0.5.16",
+    "commander": "^12.1.0",
+    "ignore": "^7.0.5",
+    "nunjucks": "^3.2.4",
+    "tar": "^7.5.1",
+    "yaml": "^2.4.2",
+    "zod": "^3.25.0",
+    "zod-to-json-schema": "^3.24.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.12.0",
+    "@types/adm-zip": "^0.5.7",
+    "@types/node": "^20.11.0",
+    "@types/nunjucks": "^3.2.5",
+    "@typescript-eslint/eslint-plugin": "^8.9.0",
+    "@typescript-eslint/parser": "^8.9.0",
+    "@vitest/coverage-v8": "^2.1.1",
+    "eslint": "^9.12.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.3.3",
+    "rimraf": "^5.0.5",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.7.0",
+    "tsx": "^4.17.0",
+    "typescript": "5.5.4",
+    "vitest": "^2.1.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node ./scripts/copy-resources.mjs",
+    "clean": "rimraf dist",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint .",
+    "lint:fix": "pnpm lint --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prompts:generate": "tsx src/devtools/generate_prompt_factory.ts"
+  }
+}