stealthos-cli 0.1.0-alpha.3 → 0.1.0-alpha.4

package/ai/server/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "ai-os-server",
+  "version": "1.1.0",
+  "description": "AI Operating System — MCP daemon + Runtime v0.1 (Project State / Context Packager / Snapshot)",
+  "type": "module",
+  "main": "aios-server.mjs",
+  "bin": {
+    "aios-server": "./aios-server.mjs"
+  },
+  "scripts": {
+    "start": "node aios-server.mjs",
+    "http": "node aios-server.mjs --http",
+    "build": "tsc --noEmit && esbuild src/index.ts --bundle --platform=node --target=node18 --format=esm --outfile=dist/index.mjs --external:ts-morph --external:commander",
+    "build:standalone": "tsc --noEmit && esbuild src/index.ts --bundle --platform=node --target=node18 --format=esm --outfile=dist/index.mjs",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "ts-morph": "^22.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.0",
+    "esbuild": "^0.21.0",
+    "typescript": "^5.4.0"
+  }
+}

package/ai/server/src/analyzer/graph-builder.ts

@@ -0,0 +1,92 @@
+import { dirname, join, normalize } from "node:path";
+import type { DependencyGraph, ModuleInfo } from "../types.js";
+
+export function buildGraph(modules: ModuleInfo[]): DependencyGraph {
+  const nodeSet = new Set(modules.map((m) => m.id));
+  const edges: Array<{ from: string; to: string }> = [];
+
+  for (const m of modules) {
+    for (const imp of m.imports) {
+      const resolved = resolveImport(m.id, imp, nodeSet);
+      if (resolved && resolved !== m.id) {
+        edges.push({ from: m.id, to: resolved });
+      }
+    }
+  }
+
+  const cycles = detectCycles(Array.from(nodeSet), edges);
+  return { nodes: Array.from(nodeSet), edges, cycles };
+}
+
+function resolveImport(fromModule: string, spec: string, knownNodes: Set<string>): string | null {
+  if (!spec.startsWith(".")) return null;
+  const fromDir = dirname(fromModule);
+  const target = normalize(join(fromDir, spec)).replace(/\\/g, "/");
+  const candidates = [
+    target,
+    target + ".ts",
+    target + ".tsx",
+    target + ".mts",
+    target + ".js",
+    target + ".mjs",
+    target + ".jsx",
+    normalize(join(target, "index.ts")).replace(/\\/g, "/"),
+    normalize(join(target, "index.tsx")).replace(/\\/g, "/"),
+    normalize(join(target, "index.mts")).replace(/\\/g, "/"),
+    normalize(join(target, "index.js")).replace(/\\/g, "/"),
+    normalize(join(target, "index.mjs")).replace(/\\/g, "/"),
+  ];
+  for (const c of candidates) {
+    if (knownNodes.has(c)) return c;
+  }
+  // Try stripping .js extension (TS bundler convention)
+  if (spec.endsWith(".js")) {
+    const base = spec.slice(0, -3);
+    return resolveImport(fromModule, base, knownNodes);
+  }
+  return null;
+}
+
+function detectCycles(
+  nodes: string[],
+  edges: Array<{ from: string; to: string }>,
+): string[][] {
+  const adj = new Map<string, string[]>();
+  for (const n of nodes) adj.set(n, []);
+  for (const e of edges) adj.get(e.from)?.push(e.to);
+
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = new Map<string, number>();
+  for (const n of nodes) color.set(n, WHITE);
+  const cycles: string[][] = [];
+  const seen = new Set<string>();
+
+  function dfs(node: string, stack: string[]): void {
+    color.set(node, GRAY);
+    stack.push(node);
+    for (const next of adj.get(node) ?? []) {
+      if (color.get(next) === GRAY) {
+        const idx = stack.indexOf(next);
+        if (idx >= 0) {
+          const cycle = stack.slice(idx);
+          const key = [...cycle].sort().join("|");
+          if (!seen.has(key)) {
+            seen.add(key);
+            cycles.push([...cycle, next]);
+          }
+        }
+      } else if (color.get(next) === WHITE) {
+        dfs(next, stack);
+      }
+    }
+    stack.pop();
+    color.set(node, BLACK);
+  }
+
+  for (const n of nodes) {
+    if (color.get(n) === WHITE) dfs(n, []);
+  }
+  return cycles;
+}

package/ai/server/src/analyzer/index.ts

@@ -0,0 +1,191 @@
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { ModuleInfo, ProjectState, ProjectStats } from "../types.js";
+import { buildGraph } from "./graph-builder.js";
+import { mapModules } from "./module-mapper.js";
+import { detectSmells } from "./smell-detector.js";
+import { detectStack } from "./stack-detector.js";
+
+const RUNTIME_VERSION = "4.1.0";
+
+export interface AnalyzeOptions {
+  write?: boolean;
+  scanDirs?: string[];
+}
+
+export async function analyzeProject(
+  projectRoot: string,
+  options: AnalyzeOptions = {},
+): Promise<ProjectState> {
+  const stack = await detectStack(projectRoot);
+  const modules = await mapModules(projectRoot, { scanDirs: options.scanDirs });
+  const graph = buildGraph(modules);
+  const smells = await detectSmells(modules, graph, projectRoot);
+  const stats = await computeStats(projectRoot, modules);
+
+  const state: ProjectState = {
+    version: RUNTIME_VERSION,
+    generated_at: new Date().toISOString(),
+    project_root: projectRoot,
+    stack,
+    modules,
+    graph,
+    smells,
+    stats,
+  };
+
+  if (options.write !== false) {
+    const ctxDir = join(projectRoot, ".ai", "context");
+    await mkdir(ctxDir, { recursive: true });
+    await writeFile(
+      join(ctxDir, "project-state.json"),
+      JSON.stringify(state, null, 2),
+      "utf8",
+    );
+    await writeFile(join(ctxDir, "project-state.md"), renderMarkdown(state), "utf8");
+  }
+
+  return state;
+}
+
+async function computeStats(
+  projectRoot: string,
+  modules: ModuleInfo[],
+): Promise<ProjectStats> {
+  const filesByLang: Record<string, number> = {};
+  let totalLines = 0;
+  for (const m of modules) {
+    filesByLang[m.language] = (filesByLang[m.language] ?? 0) + 1;
+    totalLines += m.size_lines;
+  }
+  const largest = [...modules]
+    .sort((a, b) => b.size_lines - a.size_lines)
+    .slice(0, 10)
+    .map((m) => ({ path: m.path, lines: m.size_lines }));
+  const totalFiles = await walkCount(projectRoot);
+  return {
+    total_files: totalFiles,
+    total_lines: totalLines,
+    files_by_language: filesByLang,
+    largest_files: largest,
+  };
+}
+
+const COUNT_IGNORED = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".runtime",
+  "archive",
+  ".turbo",
+  ".vercel",
+  ".next",
+  ".nuxt",
+  "coverage",
+]);
+
+async function walkCount(dir: string): Promise<number> {
+  let count = 0;
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const e of entries) {
+    if (COUNT_IGNORED.has(e.name)) continue;
+    if (e.name.startsWith(".") && e.name !== ".ai" && e.name !== ".claude") continue;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) count += await walkCount(p);
+    else if (e.isFile()) count++;
+  }
+  return count;
+}
+
+function renderMarkdown(state: ProjectState): string {
+  const lines: string[] = [];
+  lines.push("# Project State", "");
+  lines.push(`**Generated:** ${state.generated_at}`);
+  lines.push(`**Runtime:** v${state.version}`);
+  lines.push(`**Root:** \`${state.project_root}\``, "");
+
+  lines.push("## Stack", "");
+  lines.push(`- **Languages:** ${state.stack.languages.join(", ") || "(none detected)"}`);
+  lines.push(`- **Frameworks:** ${state.stack.frameworks.join(", ") || "(none)"}`);
+  if (state.stack.package_manager) {
+    lines.push(`- **Package manager:** ${state.stack.package_manager}`);
+  }
+  if (state.stack.databases && state.stack.databases.length) {
+    lines.push(`- **Databases:** ${state.stack.databases.join(", ")}`);
+  }
+  if (state.stack.test_frameworks && state.stack.test_frameworks.length) {
+    lines.push(`- **Test frameworks:** ${state.stack.test_frameworks.join(", ")}`);
+  }
+  if (state.stack.linters && state.stack.linters.length) {
+    lines.push(`- **Linters:** ${state.stack.linters.join(", ")}`);
+  }
+  lines.push("");
+
+  lines.push("## Stats", "");
+  lines.push(`- **Total files (repo):** ${state.stats.total_files}`);
+  lines.push(`- **Modules tracked (AST/regex):** ${state.modules.length}`);
+  lines.push(`- **Total lines in modules:** ${state.stats.total_lines}`);
+  lines.push(`- **Dependency edges:** ${state.graph.edges.length}`);
+  lines.push(`- **Circular dependencies:** ${state.graph.cycles.length}`);
+  lines.push(`- **Smells found:** ${state.smells.length}`);
+  lines.push("");
+
+  lines.push("### Files by language", "");
+  const sorted = Object.entries(state.stats.files_by_language).sort((a, b) => b[1] - a[1]);
+  if (sorted.length === 0) {
+    lines.push("_(no language buckets — nothing scanned)_");
+  } else {
+    for (const [lang, n] of sorted) {
+      lines.push(`- \`${lang}\`: ${n}`);
+    }
+  }
+  lines.push("");
+
+  if (state.stats.largest_files.length) {
+    lines.push("### Largest files", "");
+    for (const f of state.stats.largest_files) {
+      lines.push(`- \`${f.path}\` — ${f.lines} lines`);
+    }
+    lines.push("");
+  }
+
+  if (state.smells.length) {
+    lines.push("## Smells (top 20)", "");
+    for (const s of state.smells.slice(0, 20)) {
+      const loc = `${s.location.file}${s.location.line ? ":" + s.location.line : ""}`;
+      lines.push(`- **${s.kind}** [${s.severity}] \`${loc}\` — ${s.message}`);
+    }
+    lines.push("");
+  }
+
+  if (state.graph.cycles.length) {
+    lines.push("## Cyclic dependencies", "");
+    for (const c of state.graph.cycles) {
+      lines.push(`- ${c.join(" → ")}`);
+    }
+    lines.push("");
+  }
+
+  if (state.modules.length) {
+    lines.push("## Modules", "");
+    for (const m of state.modules.slice(0, 50)) {
+      lines.push(
+        `- \`${m.path}\` (${m.language}, ${m.size_lines} lines, ${m.imports.length} imports, ${m.exports.length} exports)`,
+      );
+    }
+    if (state.modules.length > 50) {
+      lines.push(`- … and ${state.modules.length - 50} more`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export { detectStack, mapModules, buildGraph, detectSmells };

package/ai/server/src/analyzer/module-mapper.ts

@@ -0,0 +1,171 @@
+import { readFile, readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+import { Project } from "ts-morph";
+import type { ModuleInfo } from "../types.js";
+
+const IGNORED_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".cache",
+  ".runtime",
+  "archive",
+  ".turbo",
+  ".vercel",
+]);
+
+const TS_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+const TEXT_LANG_EXTENSIONS = new Set([
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".php",
+  ".cs",
+  ".ex",
+  ".exs",
+  ".swift",
+]);
+
+export interface MapOptions {
+  scanDirs?: string[];
+}
+
+export async function mapModules(
+  projectRoot: string,
+  options: MapOptions = {},
+): Promise<ModuleInfo[]> {
+  const scanDirs = options.scanDirs ?? [".ai/server/src", "src", "lib", "app", "packages"];
+  const allFiles: string[] = [];
+
+  for (const d of scanDirs) {
+    const abs = join(projectRoot, d);
+    if (!existsSync(abs)) continue;
+    await collectFiles(abs, allFiles);
+  }
+
+  const modules: ModuleInfo[] = [];
+
+  const tsFiles = allFiles.filter((f) => TS_EXTENSIONS.has(extname(f)));
+  if (tsFiles.length > 0) {
+    const project = new Project({
+      useInMemoryFileSystem: false,
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: { allowJs: true, noEmit: true },
+    });
+    for (const f of tsFiles) {
+      try {
+        project.addSourceFileAtPath(f);
+      } catch {
+        // ignore unreadable/odd file
+      }
+    }
+    for (const sf of project.getSourceFiles()) {
+      const path = sf.getFilePath();
+      const relPath = relative(projectRoot, path).replace(/\\/g, "/");
+      const text = sf.getFullText();
+      const lines = text.split("\n").length;
+      const imports: string[] = [];
+      for (const imp of sf.getImportDeclarations()) {
+        const v = imp.getModuleSpecifierValue();
+        if (v) imports.push(v);
+      }
+      for (const exp of sf.getExportDeclarations()) {
+        const v = exp.getModuleSpecifierValue();
+        if (v) imports.push(v);
+      }
+      const exportsList: string[] = [];
+      for (const [name] of sf.getExportedDeclarations()) {
+        exportsList.push(name);
+      }
+      modules.push({
+        id: relPath,
+        name: relPath,
+        path: relPath,
+        kind: "file",
+        language: extname(path) === ".tsx" || extname(path) === ".jsx" ? "tsx" : "typescript",
+        size_lines: lines,
+        imports,
+        exports: exportsList,
+      });
+    }
+  }
+
+  for (const f of allFiles) {
+    const ext = extname(f);
+    if (!TEXT_LANG_EXTENSIONS.has(ext)) continue;
+    const text = await readFile(f, "utf8").catch(() => "");
+    if (!text) continue;
+    const lines = text.split("\n").length;
+    const relPath = relative(projectRoot, f).replace(/\\/g, "/");
+    const lang = guessLanguage(ext);
+    modules.push({
+      id: relPath,
+      name: relPath,
+      path: relPath,
+      kind: "file",
+      language: lang,
+      size_lines: lines,
+      imports: extractImportsByLanguage(text, lang),
+      exports: [],
+    });
+  }
+
+  return modules;
+}
+
+async function collectFiles(dir: string, out: string[]): Promise<void> {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (IGNORED_DIRS.has(e.name)) continue;
+    if (e.name.startsWith(".") && e.name !== ".ai" && e.name !== ".claude") continue;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) {
+      await collectFiles(p, out);
+    } else if (e.isFile()) {
+      out.push(p);
+    }
+  }
+}
+
+function guessLanguage(ext: string): string {
+  const map: Record<string, string> = {
+    ".py": "python",
+    ".rb": "ruby",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".php": "php",
+    ".cs": "csharp",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".swift": "swift",
+  };
+  return map[ext] ?? "unknown";
+}
+
+function extractImportsByLanguage(text: string, lang: string): string[] {
+  const imports: string[] = [];
+  let re: RegExp | null = null;
+  if (lang === "python") re = /^(?:from|import)\s+([\w.]+)/gm;
+  else if (lang === "go") re = /import\s+"([^"]+)"/g;
+  else if (lang === "rust") re = /^use\s+([\w:]+)/gm;
+  else if (lang === "java" || lang === "kotlin") re = /^import\s+([\w.]+)/gm;
+  if (!re) return imports;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text))) imports.push(m[1]);
+  return imports;
+}

package/ai/server/src/analyzer/smell-detector.ts

@@ -0,0 +1,54 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { DependencyGraph, ModuleInfo, Smell } from "../types.js";
+
+const LARGE_FILE_THRESHOLD = 300;
+
+export async function detectSmells(
+  modules: ModuleInfo[],
+  graph: DependencyGraph,
+  projectRoot: string,
+): Promise<Smell[]> {
+  const smells: Smell[] = [];
+
+  for (const cycle of graph.cycles) {
+    smells.push({
+      kind: "circular_dependency",
+      severity: "high",
+      location: { file: cycle[0] },
+      message: `Circular dependency: ${cycle.join(" → ")}`,
+    });
+  }
+
+  for (const m of modules) {
+    if (m.size_lines > LARGE_FILE_THRESHOLD) {
+      smells.push({
+        kind: "large_file",
+        severity: m.size_lines > 1000 ? "high" : "medium",
+        location: { file: m.path },
+        message: `File has ${m.size_lines} lines (soft limit: ${LARGE_FILE_THRESHOLD})`,
+      });
+    }
+  }
+
+  for (const m of modules) {
+    if (m.language === "unknown" || m.language === "markdown") continue;
+    const abs = join(projectRoot, m.path);
+    const text = await readFile(abs, "utf8").catch(() => "");
+    if (!text) continue;
+    const lines = text.split("\n");
+    lines.forEach((line, idx) => {
+      const isFixme = /\bFIXME\b/i.test(line);
+      const isTodo = /\bTODO\b/i.test(line);
+      if (!isFixme && !isTodo) return;
+      smells.push({
+        kind: isFixme ? "fixme_comment" : "todo_comment",
+        severity: isFixme ? "medium" : "low",
+        location: { file: m.path, line: idx + 1 },
+        message: line.trim().slice(0, 140),
+      });
+    });
+  }
+
+  return smells;
+}

package/ai/server/src/analyzer/stack-detector.ts

@@ -0,0 +1,70 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { StackInfo } from "../types.js";
+
+export async function detectStack(projectRoot: string): Promise<StackInfo> {
+  const fallback: StackInfo = { languages: [], frameworks: [] };
+
+  return new Promise((resolve) => {
+    const isWin = process.platform === "win32";
+    const aiDir = join(projectRoot, ".ai");
+    const scriptPs = join(aiDir, "scripts", "detect-stack.ps1");
+    const scriptSh = join(aiDir, "scripts", "detect-stack.sh");
+    const useScript = isWin ? scriptPs : existsSync(scriptSh) ? scriptSh : scriptPs;
+
+    if (!existsSync(useScript)) {
+      resolve(fallback);
+      return;
+    }
+
+    const cmd = isWin ? "powershell" : "bash";
+    const args = isWin
+      ? [
+          "-NoProfile",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-File",
+          useScript,
+          "-TargetPath",
+          projectRoot,
+        ]
+      : [useScript, "--target", projectRoot];
+
+    const child = spawn(cmd, args, { cwd: projectRoot });
+    let out = "";
+    child.stdout.on("data", (d) => (out += d));
+    child.stderr.on("data", () => {});
+
+    child.on("close", () => {
+      try {
+        const jsonStart = out.indexOf("{");
+        const jsonEnd = out.lastIndexOf("}");
+        if (jsonStart >= 0 && jsonEnd > jsonStart) {
+          const parsed = JSON.parse(out.slice(jsonStart, jsonEnd + 1)) as Record<string, unknown>;
+          resolve(normalize(parsed));
+          return;
+        }
+      } catch {
+        // fall through
+      }
+      resolve(fallback);
+    });
+
+    child.on("error", () => resolve(fallback));
+  });
+}
+
+function normalize(raw: Record<string, unknown>): StackInfo {
+  const arr = (v: unknown): string[] | undefined =>
+    Array.isArray(v) ? (v as unknown[]).map(String) : undefined;
+  return {
+    languages: arr(raw.languages) ?? [],
+    frameworks: arr(raw.frameworks) ?? [],
+    package_manager: typeof raw.package_manager === "string" ? raw.package_manager : undefined,
+    databases: arr(raw.databases),
+    test_frameworks: arr(raw.test_frameworks),
+    linters: arr(raw.linters),
+    ci_cd: arr(raw.ci_cd),
+  };
+}

package/ai/server/src/index.ts

@@ -0,0 +1,16 @@
+export * as analyzer from "./analyzer/index.js";
+export * as packager from "./packager/index.js";
+export * as snapshot from "./snapshot/index.js";
+export type {
+  ProjectState,
+  StackInfo,
+  ModuleInfo,
+  DependencyGraph,
+  Smell,
+  ProjectStats,
+  ContextPackage,
+  SnapshotManifest,
+  SnapshotDiff,
+} from "./types.js";
+
+export const RUNTIME_VERSION = "4.1.0";