akanjs 0.0.1 → 2.0.0-beta.1

package/devkit/sshTunnel.ts

@@ -0,0 +1,151 @@
+import { type Channel, Client, type ConnectConfig } from "ssh2";
+
+export interface SshTunnelOptions {
+  localHost?: string;
+  localPort: number;
+  srcHost?: string;
+  srcPort?: number;
+  dstHost: string;
+  dstPort: number;
+  sshOptions: ConnectConfig;
+}
+
+export interface SshTunnel {
+  close(): void;
+}
+
+interface TunnelSocketData {
+  stream?: Channel;
+  pending: Buffer[];
+  closed: boolean;
+}
+
+type BunServer = { stop(): void };
+type BunSocket = Bun.Socket<TunnelSocketData>;
+
+const closeQuietly = (close: () => void) => {
+  try {
+    close();
+  } catch {
+  }
+};
+
+const createSshClient = async (options: SshTunnelOptions) =>
+  new Promise<Client>((resolve, reject) => {
+    const client = new Client();
+
+    const cleanup = () => {
+      client.off("ready", onReady);
+      client.off("error", onError);
+      client.off("close", onClose);
+    };
+
+    const onReady = () => {
+      cleanup();
+      resolve(client);
+    };
+
+    const onError = (error: Error) => {
+      cleanup();
+      reject(error);
+    };
+
+    const onClose = () => {
+      cleanup();
+      reject(new Error("SSH tunnel closed before it was ready"));
+    };
+
+    client.once("ready", onReady);
+    client.once("error", onError);
+    client.once("close", onClose);
+    client.connect({ readyTimeout: 10000, ...options.sshOptions });
+  });
+
+export const createSshTunnel = async (options: SshTunnelOptions): Promise<SshTunnel> => {
+  const client = await createSshClient(options);
+  const sockets = new Set<BunSocket>();
+  let closing = false;
+
+  const closeSocket = (socket: BunSocket, error?: Error) => {
+    sockets.delete(socket);
+    closeBunSocket(socket, error);
+  };
+
+  try {
+    const server = Bun.listen<TunnelSocketData>({
+      hostname: options.localHost ?? "127.0.0.1",
+      port: options.localPort,
+      socket: {
+        open(socket) {
+          sockets.add(socket);
+          socket.data = { pending: [], closed: false };
+
+          client.forwardOut(
+            options.srcHost ?? "127.0.0.1",
+            options.srcPort ?? options.localPort,
+            options.dstHost,
+            options.dstPort,
+            (error, stream) => {
+              if (error) {
+                closeSocket(socket, error);
+                return;
+              }
+
+              if (socket.data.closed) {
+                stream.destroy();
+                return;
+              }
+
+              socket.data.stream = stream;
+              stream.on("data", (chunk: Buffer) => socket.write(chunk));
+              stream.once("close", () => closeSocket(socket));
+              stream.once("error", (streamError: Error) => closeSocket(socket, streamError));
+
+              for (const chunk of socket.data.pending) stream.write(chunk);
+              socket.data.pending = [];
+            },
+          );
+        },
+        data(socket, chunk) {
+          const buffer = Buffer.from(chunk);
+          if (socket.data.stream) socket.data.stream.write(buffer);
+          else socket.data.pending.push(buffer);
+        },
+        close(socket) {
+          closeSocket(socket);
+        },
+        error(socket, error) {
+          closeSocket(socket, error);
+        },
+      },
+    });
+
+    const closeTunnel = (error?: Error) => {
+      if (closing) return;
+      closing = true;
+      for (const socket of sockets) closeSocket(socket, error);
+      closeQuietly(() => client.end());
+      closeBunServer(server);
+    };
+
+    client.once("error", (error) => closeTunnel(error));
+    client.once("close", () => closeTunnel());
+
+    return { close: closeTunnel };
+  } catch (error) {
+    closeQuietly(() => client.end());
+    throw error;
+  }
+};
+
+const closeBunSocket = (socket: BunSocket, error?: Error) => {
+  if (socket.data.closed) return;
+  socket.data.closed = true;
+  if (error) socket.data.stream?.destroy();
+  else socket.data.stream?.end();
+  closeQuietly(() => socket.end());
+};
+
+const closeBunServer = (server: BunServer) => {
+  server.stop();
+};

package/devkit/streamAi.ts

@@ -0,0 +1,45 @@
+import { PromptTemplate } from "@langchain/core/prompts";
+import { RunnableSequence } from "@langchain/core/runnables";
+import { ChatOpenAI } from "@langchain/openai";
+
+interface StreamResponse {
+  content: string;
+  chunk?: string;
+}
+
+export const streamAi = async (
+  question: string,
+  callback: (chunk: string) => void = (chunk) => {
+    process.stdout.write(chunk);
+  },
+): Promise<StreamResponse> => {
+  const createStreamingModel = (apiKey = process.env.DEEPSEEK_API_KEY) => {
+    if (!apiKey) throw new Error(`process.env.DEEPSEEK_API_KEY is not set`);
+    return new ChatOpenAI({
+      modelName: "deepseek-reasoner",
+      temperature: 0.7,
+      streaming: true, // Enable streaming
+      configuration: { baseURL: "https://api.deepseek.com/v1", apiKey },
+    });
+  };
+  const createProcessingChain = () => {
+    return RunnableSequence.from([PromptTemplate.fromTemplate(`Answer concisely: {question}`), createStreamingModel()]);
+  };
+  try {
+    const chain = createProcessingChain();
+    const stream = await chain.stream({ question });
+
+    let fullResponse = "";
+    for await (const chunk of stream) {
+      const content = chunk.content;
+      if (typeof content === "string") {
+        fullResponse += content;
+        callback(content); 
+      }
+    }
+
+    return { content: fullResponse };
+  } catch (error) {
+    throw new Error("Failed to stream response");
+  }
+};

package/devkit/transforms/barrelAnalyzer.ts

@@ -0,0 +1,249 @@
+import path from "node:path";
+import { Logger } from "akanjs/common";
+
+export interface BarrelExportTarget {
+  /** Subpath specifier to emit in rewritten import, e.g. `akanjs/ui/Empty`. */
+  subpath: string;
+  /** Name as it is exported by the leaf module. */
+  originalName: string;
+}
+
+export type BarrelExportMap = Map<string, BarrelExportTarget>;
+
+export interface PackageEntry {
+  /** Package specifier (e.g. `akanjs/ui`). */
+  pkgName: string;
+  /** Absolute path of the barrel entry file. */
+  entryFile: string;
+  /** Absolute directory used as the base for subpath computation. Typically dirname(entryFile). */
+  pkgDir: string;
+  /** Preserve concrete file paths for package exports that do not support extensionless deep imports. */
+  preserveFilePath?: boolean;
+}
+
+export interface BarrelAnalyzerOptions {
+  resolvePackage: (pkgName: string) => Promise<PackageEntry | null>;
+  /** Resolve a relative specifier from `fromFile` to an absolute file path on disk. */
+  resolveRelative?: (fromFile: string, relSpec: string) => Promise<string | null>;
+}
+
+const REEXPORT_RE =
+  /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
+
+const LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
+
+const CANDIDATE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+
+export class BarrelAnalyzer {
+  readonly #logger = new Logger("BarrelAnalyzer");
+  readonly #opts: BarrelAnalyzerOptions;
+  readonly #cache = new Map<string, Promise<BarrelExportMap | null>>();
+  readonly #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
+  readonly #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
+
+  constructor(opts: BarrelAnalyzerOptions) {
+    this.#opts = opts;
+  }
+
+  analyze(pkgName: string): Promise<BarrelExportMap | null> {
+    const cached = this.#cache.get(pkgName);
+    if (cached) return cached;
+    const promise = this.#analyzeSafe(pkgName);
+    this.#cache.set(pkgName, promise);
+    return promise;
+  }
+
+  async #analyzeSafe(pkgName: string): Promise<BarrelExportMap | null> {
+    try {
+      return await this.#analyzeUncached(pkgName);
+    } catch (err) {
+      this.#logger.error(`analyze failed for ${pkgName}: ${(err as Error).message}`);
+      return null;
+    }
+  }
+
+  async #analyzeUncached(pkgName: string): Promise<BarrelExportMap | null> {
+    const pkg = await this.#opts.resolvePackage(pkgName);
+    if (!pkg) return null;
+    const map: BarrelExportMap = new Map();
+    const visited = new Set<string>();
+    await this.#walk(pkg.entryFile, pkg, map, visited);
+    return map;
+  }
+
+  async #walk(absFile: string, pkg: PackageEntry, map: BarrelExportMap, visited: Set<string>): Promise<void> {
+    if (visited.has(absFile)) return;
+    visited.add(absFile);
+    const source = await readIfExists(absFile);
+    if (source === null) return;
+    const currentSubpath = this.#subpathFor(pkg, absFile);
+    if (!currentSubpath) return;
+
+    const authoritative = this.#scanExports(source, absFile);
+
+    authoritative.delete("default");
+
+    const attributed = new Set<string>();
+
+    REEXPORT_RE.lastIndex = 0;
+    let m: RegExpExecArray | null = REEXPORT_RE.exec(source);
+    while (m !== null) {
+      const star = m[1];
+      const nsAs = m[2];
+      const namedList = m[3];
+      const spec = m[5] ?? "";
+      m = REEXPORT_RE.exec(source);
+      if (!isRelative(spec)) continue;
+
+      if (star) {
+        if (nsAs) {
+
+          authoritative.delete(nsAs);
+          continue;
+        }
+        const targetAbs = await this.#resolveRel(absFile, spec);
+        if (!targetAbs) continue;
+
+        await this.#walk(targetAbs, pkg, map, visited);
+        continue;
+      }
+
+      if (namedList !== undefined) {
+        const targetAbs = await this.#resolveRel(absFile, spec);
+        if (!targetAbs) continue;
+        const targetSubpath = this.#subpathFor(pkg, targetAbs);
+        if (!targetSubpath) continue;
+        for (const item of parseNamedList(namedList)) {
+          if (item.isType) continue;
+          if (item.imported === "default") continue;
+
+          if (!authoritative.has(item.local)) continue;
+          attributed.add(item.local);
+          if (!map.has(item.local)) {
+            map.set(item.local, { subpath: targetSubpath, originalName: item.imported });
+          }
+        }
+      }
+    }
+
+    LOCAL_NAMED_RE.lastIndex = 0;
+    let n: RegExpExecArray | null = LOCAL_NAMED_RE.exec(source);
+    while (n !== null) {
+      const body = n[1] ?? "";
+      n = LOCAL_NAMED_RE.exec(source);
+      for (const item of parseNamedList(body)) {
+        if (item.isType) continue;
+        if (item.imported === "default") continue;
+
+        if (!authoritative.has(item.local)) continue;
+        attributed.add(item.local);
+        if (!map.has(item.local)) {
+          map.set(item.local, { subpath: currentSubpath, originalName: item.imported });
+        }
+      }
+    }
+
+    for (const name of authoritative) {
+      if (attributed.has(name)) continue;
+      if (map.has(name)) continue;
+      map.set(name, { subpath: currentSubpath, originalName: name });
+    }
+  }
+
+  #scanExports(source: string, absFile: string): Set<string> {
+    try {
+      const transpiler = [".tsx", ".jsx"].includes(path.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
+      const { exports } = transpiler.scan(source);
+      return new Set(exports);
+    } catch (err) {
+      this.#logger.error(`scan failed: ${(err as Error).message}`);
+      return new Set();
+    }
+  }
+
+  #subpathFor(pkg: PackageEntry, absFile: string): string | null {
+    const rel = path.relative(pkg.pkgDir, absFile);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return null;
+    if (pkg.preserveFilePath) return `${pkg.pkgName}/${rel.split(path.sep).join("/")}`;
+    const noExt = stripKnownExt(rel);
+
+    const tail = collapseIndex(noExt);
+    if (tail === "") return pkg.pkgName;
+    return `${pkg.pkgName}/${tail.split(path.sep).join("/")}`;
+  }
+
+  async #resolveRel(fromFile: string, relSpec: string): Promise<string | null> {
+    if (this.#opts.resolveRelative) return this.#opts.resolveRelative(fromFile, relSpec);
+    return defaultResolveRelative(fromFile, relSpec);
+  }
+}
+
+interface NamedItem {
+  imported: string;
+  local: string;
+  isType: boolean;
+}
+
+const parseNamedList = (listBody: string): NamedItem[] => {
+  const out: NamedItem[] = [];
+  for (const raw of listBody.split(",")) {
+    const s = raw.trim();
+    if (!s) continue;
+    let rest = s;
+    let isType = false;
+    if (rest.startsWith("type ")) {
+      isType = true;
+      rest = rest.slice(5).trim();
+    }
+    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
+    if (asMatch) {
+      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
+      continue;
+    }
+    if (/^\w+$/.test(rest)) {
+      out.push({ imported: rest, local: rest, isType });
+    }
+  }
+  return out;
+};
+
+const isRelative = (spec: string): boolean => {
+  return spec.startsWith("./") || spec.startsWith("../") || spec === "." || spec === "..";
+};
+
+const readIfExists = async (absFile: string): Promise<string | null> => {
+  const file = Bun.file(absFile);
+  if (!(await file.exists())) return null;
+  return file.text();
+};
+
+const defaultResolveRelative = async (fromFile: string, relSpec: string): Promise<string | null> => {
+  const baseDir = path.dirname(fromFile);
+  const joined = path.resolve(baseDir, relSpec);
+  if (path.extname(joined)) {
+    if (await Bun.file(joined).exists()) return joined;
+    return null;
+  }
+  for (const ext of CANDIDATE_EXTS) {
+    const cand = joined + ext;
+    if (await Bun.file(cand).exists()) return cand;
+  }
+  for (const ext of CANDIDATE_EXTS) {
+    const cand = path.join(joined, `index${ext}`);
+    if (await Bun.file(cand).exists()) return cand;
+  }
+  return null;
+};
+
+const stripKnownExt = (relPath: string): string => {
+  for (const ext of CANDIDATE_EXTS) {
+    if (relPath.endsWith(ext)) return relPath.slice(0, -ext.length);
+  }
+  return relPath;
+};
+
+const collapseIndex = (relPathNoExt: string): string => {
+  const parts = relPathNoExt.split(path.sep);
+  if (parts[parts.length - 1] === "index") parts.pop();
+  return parts.join(path.sep);
+};