@adanami/kaleido 0.1.0

package/dist/server/ts/worker.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+
+// src/server/ts/worker.ts
+import { parentPort, workerData } from "worker_threads";
+
+// src/server/ts/service.ts
+import { createRequire } from "module";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+var PROJECT_IDLE_DISPOSE_MS = 10 * 60 * 1e3;
+var TsService = class {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+    const loaded = loadTypescript(repoRoot);
+    this.ts = loaded.ts;
+    this.tsSource = loaded.source;
+    this.documentRegistry = this.ts.createDocumentRegistry();
+  }
+  repoRoot;
+  ts;
+  tsSource;
+  projects = /* @__PURE__ */ new Map();
+  documentRegistry;
+  get tsVersionInfo() {
+    return `${this.ts.version} (${this.tsSource})`;
+  }
+  isSupportedFile(path) {
+    return /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(path);
+  }
+  toAbsPath(repoRelPath) {
+    const normalized = repoRelPath.replace(/\\/g, "/");
+    if (isAbsolute(normalized) || normalized.split("/").includes("..")) {
+      throw new Error("Invalid path");
+    }
+    const abs = resolve(this.repoRoot, normalized);
+    if (abs !== this.repoRoot && !abs.startsWith(`${this.repoRoot}${sep}`)) {
+      throw new Error("Path outside repository");
+    }
+    return abs;
+  }
+  getProjectFor(absPath) {
+    const configPath = this.ts.findConfigFile(dirname(absPath), this.ts.sys.fileExists, "tsconfig.json");
+    if (!configPath) return null;
+    let project = this.projects.get(configPath);
+    if (!project) {
+      project = new Project(this.ts, configPath, this.documentRegistry);
+      this.projects.set(configPath, project);
+    }
+    project.touch();
+    this.disposeIdleProjects();
+    return project;
+  }
+  hover(params) {
+    const absPath = this.toAbsPath(params.path);
+    if (!this.isSupportedFile(absPath)) return null;
+    const project = this.getProjectFor(absPath);
+    if (!project) return null;
+    return project.hover(absPath, params.line, params.column, params.content);
+  }
+  diagnostics(params) {
+    const absPath = this.toAbsPath(params.path);
+    if (!this.isSupportedFile(absPath)) return [];
+    const project = this.getProjectFor(absPath);
+    if (!project) return [];
+    return project.diagnostics(absPath, params.content);
+  }
+  definition(params) {
+    return this.locate("definition", params);
+  }
+  references(params) {
+    return this.locate("references", params);
+  }
+  locate(kind, params) {
+    const absPath = this.toAbsPath(params.path);
+    if (!this.isSupportedFile(absPath)) return [];
+    const project = this.getProjectFor(absPath);
+    if (!project) return [];
+    const locations = kind === "definition" ? project.definition(absPath, params.line, params.column, params.content) : project.references(absPath, params.line, params.column, params.content);
+    const result = [];
+    for (const location of locations) {
+      if (location.path === this.repoRoot || !location.path.startsWith(`${this.repoRoot}${sep}`)) {
+        continue;
+      }
+      result.push({ ...location, path: relative(this.repoRoot, location.path).split(sep).join("/") });
+    }
+    return result;
+  }
+  /** diff 取得後にバックグラウンドで Program を構築しておく (初回 hover の体感改善) */
+  warmup(repoRelPaths) {
+    setImmediate(() => {
+      for (const path of repoRelPaths) {
+        try {
+          if (!this.isSupportedFile(path)) continue;
+          const absPath = this.toAbsPath(path);
+          this.getProjectFor(absPath)?.ensureProgram();
+        } catch {
+        }
+      }
+    });
+  }
+  /** watcher からのファイル変更通知 */
+  invalidateFile(repoRelPath) {
+    try {
+      const absPath = this.toAbsPath(repoRelPath);
+      for (const project of this.projects.values()) {
+        project.bumpDiskVersion(absPath);
+      }
+    } catch {
+    }
+  }
+  disposeIdleProjects() {
+    const now = Date.now();
+    for (const [key, project] of this.projects) {
+      if (now - project.lastUsedAt > PROJECT_IDLE_DISPOSE_MS) {
+        project.dispose();
+        this.projects.delete(key);
+      }
+    }
+  }
+};
+function loadTypescript(repoRoot) {
+  const require2 = createRequire(join(repoRoot, "noop.js"));
+  try {
+    const projectTs = require2("typescript");
+    if (typeof projectTs.createLanguageService === "function") {
+      return { ts: projectTs, source: "project" };
+    }
+  } catch {
+  }
+  const bundledRequire = createRequire(import.meta.url);
+  return { ts: bundledRequire("typescript"), source: "bundled" };
+}
+var Project = class {
+  constructor(ts, configPath, documentRegistry) {
+    this.ts = ts;
+    this.projectDir = dirname(configPath);
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    const parsed = ts.parseJsonConfigFileContent(
+      configFile.config ?? {},
+      ts.sys,
+      this.projectDir,
+      void 0,
+      configPath
+    );
+    this.compilerOptions = parsed.options;
+    this.rootFiles = new Set(parsed.fileNames);
+    const host = {
+      getScriptFileNames: () => [...this.rootFiles, ...this.extraRoots],
+      getScriptVersion: (fileName) => {
+        const overlay = this.overlays.get(fileName);
+        if (overlay) return `overlay-${overlay.version}`;
+        return `disk-${this.diskVersions.get(fileName) ?? 0}`;
+      },
+      getScriptSnapshot: (fileName) => {
+        const overlay = this.overlays.get(fileName);
+        if (overlay) return ts.ScriptSnapshot.fromString(overlay.content);
+        const content = ts.sys.readFile(fileName);
+        if (content === void 0) return void 0;
+        return ts.ScriptSnapshot.fromString(content);
+      },
+      getCurrentDirectory: () => this.projectDir,
+      getCompilationSettings: () => this.compilerOptions,
+      getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+      fileExists: (fileName) => this.overlays.has(fileName) || ts.sys.fileExists(fileName),
+      readFile: (fileName) => this.overlays.get(fileName)?.content ?? ts.sys.readFile(fileName),
+      readDirectory: ts.sys.readDirectory,
+      directoryExists: ts.sys.directoryExists,
+      getDirectories: ts.sys.getDirectories,
+      realpath: ts.sys.realpath
+    };
+    this.languageService = ts.createLanguageService(host, documentRegistry);
+  }
+  ts;
+  languageService;
+  rootFiles;
+  extraRoots = /* @__PURE__ */ new Set();
+  overlays = /* @__PURE__ */ new Map();
+  diskVersions = /* @__PURE__ */ new Map();
+  compilerOptions;
+  projectDir;
+  lastUsedAt = Date.now();
+  touch() {
+    this.lastUsedAt = Date.now();
+  }
+  ensureProgram() {
+    this.languageService.getProgram();
+  }
+  dispose() {
+    this.languageService.dispose();
+  }
+  bumpDiskVersion(absPath) {
+    this.diskVersions.set(absPath, (this.diskVersions.get(absPath) ?? 0) + 1);
+  }
+  ensureFileInProject(absPath) {
+    if (!this.rootFiles.has(absPath) && !this.extraRoots.has(absPath)) {
+      this.extraRoots.add(absPath);
+    }
+  }
+  syncOverlay(absPath, content) {
+    const existing = this.overlays.get(absPath);
+    if (content === void 0) {
+      if (existing) this.overlays.delete(absPath);
+      return;
+    }
+    if (existing?.content !== content) {
+      this.overlays.set(absPath, {
+        content,
+        version: (existing?.version ?? 0) + 1
+      });
+    }
+  }
+  getSourceFile(absPath) {
+    return this.languageService.getProgram()?.getSourceFile(absPath);
+  }
+  hover(absPath, line, column, content) {
+    this.ensureFileInProject(absPath);
+    this.syncOverlay(absPath, content);
+    const sourceFile = this.getSourceFile(absPath);
+    if (!sourceFile) return null;
+    let offset;
+    try {
+      offset = this.ts.getPositionOfLineAndCharacter(sourceFile, line - 1, column - 1);
+    } catch {
+      return null;
+    }
+    const info = this.languageService.getQuickInfoAtPosition(absPath, offset);
+    if (!info) return null;
+    const contents = [];
+    const display = this.ts.displayPartsToString(info.displayParts);
+    if (display) contents.push("```typescript\n" + display + "\n```");
+    const docs = this.ts.displayPartsToString(info.documentation);
+    if (docs) contents.push(docs);
+    for (const tag of info.tags ?? []) {
+      const text = this.ts.displayPartsToString(tag.text);
+      contents.push(`*@${tag.name}*${text ? ` \u2014 ${text}` : ""}`);
+    }
+    if (contents.length === 0) return null;
+    const start = this.ts.getLineAndCharacterOfPosition(sourceFile, info.textSpan.start);
+    const end = this.ts.getLineAndCharacterOfPosition(
+      sourceFile,
+      info.textSpan.start + info.textSpan.length
+    );
+    return {
+      contents,
+      range: {
+        startLine: start.line + 1,
+        startColumn: start.character + 1,
+        endLine: end.line + 1,
+        endColumn: end.character + 1
+      }
+    };
+  }
+  definition(absPath, line, column, content) {
+    const offset = this.prepareOffset(absPath, line, column, content);
+    if (offset === null) return [];
+    const defs = this.languageService.getDefinitionAtPosition(absPath, offset) ?? [];
+    return this.spansToLocations(defs);
+  }
+  references(absPath, line, column, content) {
+    const offset = this.prepareOffset(absPath, line, column, content);
+    if (offset === null) return [];
+    const refs = this.languageService.getReferencesAtPosition(absPath, offset) ?? [];
+    return this.spansToLocations(refs);
+  }
+  /** overlay 同期 + 1-based line/column → offset 変換 */
+  prepareOffset(absPath, line, column, content) {
+    this.ensureFileInProject(absPath);
+    this.syncOverlay(absPath, content);
+    const sourceFile = this.getSourceFile(absPath);
+    if (!sourceFile) return null;
+    try {
+      return this.ts.getPositionOfLineAndCharacter(sourceFile, line - 1, column - 1);
+    } catch {
+      return null;
+    }
+  }
+  spansToLocations(entries) {
+    const program = this.languageService.getProgram();
+    const result = [];
+    for (const entry of entries) {
+      const targetSf = program?.getSourceFile(entry.fileName);
+      if (!targetSf) continue;
+      const start = this.ts.getLineAndCharacterOfPosition(targetSf, entry.textSpan.start);
+      const end = this.ts.getLineAndCharacterOfPosition(
+        targetSf,
+        entry.textSpan.start + entry.textSpan.length
+      );
+      result.push({
+        path: entry.fileName,
+        startLine: start.line + 1,
+        startColumn: start.character + 1,
+        endLine: end.line + 1,
+        endColumn: end.character + 1
+      });
+    }
+    return result;
+  }
+  diagnostics(absPath, content) {
+    this.ensureFileInProject(absPath);
+    this.syncOverlay(absPath, content);
+    const sourceFile = this.getSourceFile(absPath);
+    if (!sourceFile) return [];
+    const all = [
+      ...this.languageService.getSyntacticDiagnostics(absPath),
+      ...this.languageService.getSemanticDiagnostics(absPath)
+    ];
+    const result = [];
+    for (const diag of all) {
+      if (diag.start === void 0 || diag.length === void 0) continue;
+      const start = this.ts.getLineAndCharacterOfPosition(sourceFile, diag.start);
+      const end = this.ts.getLineAndCharacterOfPosition(sourceFile, diag.start + diag.length);
+      result.push({
+        source: "ts",
+        severity: diag.category === this.ts.DiagnosticCategory.Error ? "error" : diag.category === this.ts.DiagnosticCategory.Warning ? "warning" : "info",
+        message: this.ts.flattenDiagnosticMessageText(diag.messageText, "\n"),
+        code: `TS${diag.code}`,
+        startLine: start.line + 1,
+        startColumn: start.character + 1,
+        endLine: end.line + 1,
+        endColumn: end.character + 1
+      });
+    }
+    return result;
+  }
+};
+
+// src/server/ts/worker.ts
+var port = parentPort;
+if (!port) throw new Error("ts worker must be started as a worker thread");
+var service = new TsService(workerData.repoRoot);
+port.on("message", (message) => {
+  const { id, method, params } = message;
+  try {
+    let result = null;
+    switch (method) {
+      case "hover":
+        result = service.hover(params);
+        break;
+      case "diagnostics":
+        result = service.diagnostics(params);
+        break;
+      case "definition":
+        result = service.definition(params);
+        break;
+      case "references":
+        result = service.references(params);
+        break;
+      case "warmup":
+        service.warmup(params.paths);
+        break;
+      case "invalidateFile":
+        service.invalidateFile(params.path);
+        break;
+    }
+    if (id !== void 0) port.postMessage({ id, result });
+  } catch (error) {
+    if (id !== void 0) {
+      port.postMessage({ id, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+});

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@adanami/kaleido",
+  "version": "0.1.0",
+  "description": "Monaco-based local web file viewer: browse any directory, diff git ranges, with real TypeScript hover, lint diagnostics, comments and review marks",
+  "type": "module",
+  "bin": {
+    "kaleido": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "viewer",
+    "diff",
+    "git",
+    "code-review",
+    "markdown",
+    "preview",
+    "mermaid",
+    "monaco",
+    "typescript",
+    "cli"
+  ],
+  "author": "bubble0601",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bubble0601/kaleido.git"
+  },
+  "homepage": "https://github.com/bubble0601/kaleido#readme",
+  "bugs": "https://github.com/bubble0601/kaleido/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "node scripts/dev.js",
+    "build": "pnpm run build:licenses && pnpm run build:server && pnpm run build:client",
+    "build:licenses": "node scripts/extract-licenses.mjs",
+    "build:server": "tsup",
+    "build:client": "vite build",
+    "typecheck": "tsc --noEmit -p tsconfig.node.json && tsc --noEmit -p tsconfig.client.json",
+    "start": "pnpm run build && node dist/cli/index.js",
+    "prepublishOnly": "pnpm run typecheck && pnpm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@hono/node-server": "^2.1.0",
+    "@hono/zod-validator": "^0.9.0",
+    "@iconify/react": "^6.0.2",
+    "@parcel/watcher": "^2.6.0",
+    "@tanstack/react-query": "^5.101.4",
+    "commander": "^15.0.0",
+    "env-paths": "^4.0.0",
+    "github-markdown-css": "^5.9.0",
+    "hono": "^4.13.1",
+    "marked": "^18.0.9",
+    "mermaid": "^11.16.1",
+    "monaco-editor": "^0.56.0",
+    "nanoid": "^6.0.1",
+    "open": "^11.0.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "simple-git": "^3.36.0",
+    "typescript": "~5.9.0",
+    "zod": "^4.4.3",
+    "zustand": "^5.0.14"
+  },
+  "devDependencies": {
+    "@iconify-json/vscode-icons": "^1.2.69",
+    "@iconify/utils": "^3.1.4",
+    "@tailwindcss/vite": "^4.3.3",
+    "@types/node": "^26.1.2",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.4",
+    "@vitejs/plugin-react": "^6.0.5",
+    "license-checker-rseidelsohn": "^5.0.1",
+    "tailwindcss": "^4.3.3",
+    "tsup": "^8.5.1",
+    "tsx": "^4.23.10",
+    "vite": "^8.2.1"
+  }
+}