@akanjs/devkit 3.0.0-beta.13 → 3.0.0-beta.15

package/testHelpers.ts

@@ -0,0 +1,179 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { AppExecutor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "@akanjs/devkit/executors";
+export interface CallRecord {
+  name: string;
+  args: unknown[];
+}
+
+export const createCallRecorder = () => {
+  const calls: CallRecord[] = [];
+  return {
+    calls,
+    /**
+     * `Returns` lets one recorder stand in for methods that return a value. Nothing is produced — the
+     * stub resolves to `undefined`, so use it only where the code under test does not read the result;
+     * a test that needs the value should return it from its own closure instead.
+     */
+    record<Returns = void>(name: string, ...args: unknown[]): Returns {
+      calls.push({ name, args });
+      return undefined as unknown as Returns;
+    },
+    names() {
+      return calls.map((call) => call.name);
+    },
+  };
+};
+
+export const createFakeSpinner = (recorder = createCallRecorder()) => ({
+  succeed: (message?: string) => recorder.record("spinner.succeed", message),
+  fail: (message?: string) => recorder.record("spinner.fail", message),
+});
+
+export const createFakeExecutor = <Extra extends object = object>(
+  name: string,
+  extra: Extra = {} as Extra,
+  recorder = createCallRecorder(),
+) =>
+  ({
+    name,
+    cwdPath: `/workspace/${name}`,
+    workspaceRoot: "/workspace",
+    spinning: (message: string) => {
+      recorder.record(`${name}.spinning`, message);
+      return createFakeSpinner(recorder);
+    },
+    spawn: async (...args: unknown[]) => {
+      recorder.record(`${name}.spawn`, ...args);
+      return "";
+    },
+    exec: async (...args: unknown[]) => {
+      recorder.record(`${name}.exec`, ...args);
+      return "";
+    },
+    scan: async (...args: unknown[]) => {
+      recorder.record(`${name}.scan`, ...args);
+      return { name };
+    },
+    scanSync: async (...args: unknown[]) => {
+      recorder.record(`${name}.scanSync`, ...args);
+      return { name };
+    },
+    ...extra,
+  }) as Extra & {
+    name: string;
+    cwdPath: string;
+    workspaceRoot: string;
+    spinning: (message: string) => ReturnType<typeof createFakeSpinner>;
+    spawn: (...args: unknown[]) => Promise<string>;
+    exec: (...args: unknown[]) => Promise<string>;
+    scan: (...args: unknown[]) => Promise<{ name: string }>;
+    scanSync: (...args: unknown[]) => Promise<{ name: string }>;
+  };
+
+export const makeCliTempWorkspace = async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-cli-"));
+  await mkdir(root, { recursive: true });
+  await writeText(path.join(root, ".gitignore"), "");
+  await writeText(
+    path.join(root, ".env"),
+    ["AKAN_PUBLIC_REPO_NAME=repo", "AKAN_PUBLIC_SERVE_DOMAIN=localhost", "AKAN_PUBLIC_ENV=local", ""].join("\n"),
+  );
+  const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
+  return { root, workspace };
+};
+
+export const cleanupCliTempWorkspace = async (root: string) => {
+  await rm(root, { recursive: true, force: true });
+};
+
+export const writeText = async (filePath: string, content: string) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+};
+
+export const writeJson = async (filePath: string, value: object) => {
+  await writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
+};
+
+export const createTempApp = async (appName = "demo") => {
+  const { root, workspace } = await makeCliTempWorkspace();
+  await writeJson(path.join(root, "package.json"), {
+    name: "repo",
+    version: "1.0.0",
+    description: "repo",
+    dependencies: {
+      react: "19.0.0",
+      "react-dom": "19.0.0",
+      "react-server-dom-webpack": "19.0.0",
+    },
+  });
+  await writeJson(path.join(root, "tsconfig.json"), {
+    compilerOptions: { target: "ESNext", paths: {} },
+    references: [],
+  });
+  await writeJson(path.join(root, "apps", appName, "tsconfig.json"), {
+    compilerOptions: { target: "ESNext", paths: {} },
+  });
+  await writeJson(path.join(root, "apps", appName, "package.json"), {
+    name: appName,
+    version: "1.0.0",
+    description: appName,
+    dependencies: {},
+    devDependencies: {},
+  });
+  await writeText(path.join(root, "apps", appName, "akan.config.ts"), "export default {};\n");
+  await mkdir(path.join(root, "apps", appName, "lib", "__scalar"), { recursive: true });
+  const app = AppExecutor.from(workspace, appName);
+  return { root, workspace, app };
+};
+
+export const createTempLib = async (libName = "shared") => {
+  const { root, workspace } = await makeCliTempWorkspace();
+  await writeJson(path.join(root, "package.json"), {
+    name: "repo",
+    version: "1.0.0",
+    description: "repo",
+    dependencies: {},
+    devDependencies: {},
+  });
+  await writeJson(path.join(root, "tsconfig.json"), {
+    compilerOptions: { target: "ESNext", paths: {} },
+    references: [],
+  });
+  const lib = LibExecutor.from(workspace, libName);
+  return { root, workspace, lib };
+};
+
+export const createTempPackage = async (pkgName = "@sample/tool") => {
+  const { root, workspace } = await makeCliTempWorkspace();
+  await writeJson(path.join(root, "package.json"), {
+    name: "repo",
+    version: "1.0.0",
+    description: "repo",
+    dependencies: { lodash: "4.0.0" },
+    devDependencies: { typescript: "6.0.0" },
+  });
+  await writeJson(path.join(root, "tsconfig.json"), {
+    compilerOptions: { target: "ESNext", paths: {} },
+  });
+  await writeJson(path.join(root, "pkgs", pkgName, "package.json"), {
+    name: pkgName,
+    version: "0.1.0",
+    description: "tool",
+    exports: {},
+  });
+  await writeJson(path.join(root, "pkgs", pkgName, "tsconfig.json"), {
+    compilerOptions: { target: "ESNext", paths: {} },
+  });
+  await writeText(path.join(root, "pkgs", pkgName, "index.ts"), 'import "lodash";\nexport const value = 1;\n');
+  const pkg = PkgExecutor.from(workspace, pkgName);
+  return { root, workspace, pkg };
+};
+
+export const createTempModule = async (moduleName = "post") => {
+  const { root, workspace, app } = await createTempApp("demo");
+  const module = ModuleExecutor.from(app, moduleName);
+  return { root, workspace, app, module };
+};

package/abstractCompactor.ts

@@ -1,112 +0,0 @@
-import { Logger } from "akanjs/common";
-import chalk from "chalk";
-import { AbstractDoc, type AbstractKind } from "./abstractDoc";
-import { AiSession } from "./aiEditor";
-import type { SysExecutor } from "./executors";
-
-export interface AbstractCompactOptions {
-  module?: string | null;
-  minLines?: number;
-  interactive?: boolean;
-}
-
-export interface AbstractCompactReport {
-  path: string;
-  beforeLines: number;
-  afterLines: number;
-  status: "compacted" | "unchanged" | "failed";
-}
-
-/** Rewrites bloated `*.abstract.md` files down to the invariants their source files cannot show. */
-export class AbstractCompactor {
-  static readonly #reviewRequest = `Review the compacted file you just wrote against the original.
-- Did you drop an invariant, a security reason, or a workflow step that the source files cannot show by themselves? Restore it.
-- Did you keep anything that only restates code, scaffold wording, or history? Remove it.
-- Is it in the same language as the original, within the line budget, and one short line per bullet?
-Respond with exactly one \`\`\`markdown code block holding the corrected file and nothing else. If nothing needs to change, repeat the file unchanged.`;
-
-  #sys: SysExecutor;
-  #minLines: number;
-  #interactive: boolean;
-  constructor(
-    sys: SysExecutor,
-    { minLines = AbstractDoc.compactMinLines, interactive = false }: AbstractCompactOptions = {},
-  ) {
-    this.#sys = sys;
-    this.#minLines = minLines;
-    this.#interactive = interactive;
-  }
-  async compactAll({ module }: { module?: string | null } = {}) {
-    const docs = await AbstractDoc.findAll(this.#sys, { module });
-    const targets = docs.filter((doc) => doc.lineCount > this.#minLines);
-    const reports: AbstractCompactReport[] = [];
-    // One file at a time: each doc gets its own AI session, and parallel runs would interleave the
-    // streamed response with each other and with the interactive confirm prompt.
-    for (const doc of targets) reports.push(await this.compact(doc));
-    return { scanned: docs.length, reports };
-  }
-  async compact(doc: AbstractDoc): Promise<AbstractCompactReport> {
-    const session = new AiSession("compactAbstract", {
-      workspace: this.#sys.workspace,
-      cacheKey: `${this.#sys.name}-${doc.moduleName}`,
-    });
-    const approve = !this.#interactive;
-    const compacted = await session.editMarkdown(this.#request(doc), { approve });
-    const reviewed = await session.editMarkdown(AbstractCompactor.#reviewRequest, { approve });
-    // The review answers in prose when it finds nothing to fix, so the first compaction is the fallback.
-    const next = [reviewed, compacted]
-      .map((candidate) => candidate.trim())
-      .find((candidate) => doc.canReplaceWith(candidate));
-    const beforeLines = doc.lineCount;
-    if (!next) {
-      Logger.rawLog(chalk.yellow(`${doc.path}: the editor returned no shorter abstract, keeping the current file`));
-      return { path: doc.path, beforeLines, afterLines: beforeLines, status: "failed" };
-    }
-    if (next === doc.content.trim())
-      return { path: doc.path, beforeLines, afterLines: beforeLines, status: "unchanged" };
-    const content = `${next}\n`;
-    await this.#sys.writeFile(doc.path, content);
-    return { path: doc.path, beforeLines, afterLines: AbstractDoc.lineCountOf(content), status: "compacted" };
-  }
-  #targetShape(kind: AbstractKind) {
-    if (kind === "other")
-      return "  - keep the headings that still carry information and drop the rest; do not impose a new structure";
-    return [
-      "  - `# <name> Abstract` title line",
-      "  - one declarative sentence naming what this module owns",
-      "  - `## Rules` — two to five bullets, each an invariant the code cannot show by itself",
-      "  - optional `## Workflow` — the lifecycle as an arrow chain (`draft -> signed -> active`) or a few bullets",
-    ].join("\n");
-  }
-  #request(doc: AbstractDoc) {
-    return `You are compacting an Akan.js abstract file.
-
-An abstract is the summary a coding agent reads before changing a module. Repeated edits have made this one
-bloated, and it has to shrink back to what the source files cannot show by themselves.
-
-# Target file
-${this.#sys.type}s/${this.#sys.name}/${doc.path} (${doc.kind} module "${doc.moduleName}", ${doc.lineCount} lines)
-
-# Source files in the same folder
-${doc.siblingFiles.join(", ") || "none"}
-
-# Current content
-\`\`\`markdown
-${doc.content}
-\`\`\`
-
-# Rules for the compacted file
-- Write it in the SAME language as the current content. Never translate.
-- Keep every invariant, constraint, security reason, and workflow step that the source files cannot show by
-  themselves. Merge duplicates instead of dropping either one.
-- Delete what the code already states: field lists, types, labels, signatures, file lists, and imports.
-- Delete scaffold and placeholder wording, changelog or migration history, TODOs, and any instruction about
-  reading or updating this file.
-- Never invent a rule that the current content does not state.
-- Keep every bullet to one short line, and stay under ${AbstractDoc.compactMinLines} lines in total.
-- Shape:
-${this.#targetShape(doc.kind)}
-
-Respond with exactly one \`\`\`markdown code block holding the whole new file and nothing else.`;
-  }
-}

package/aiEditor.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { parseTypescriptFileBlocks, preserveTypescriptResponseContent } from "./aiEditor";
-
-describe("parseTypescriptFileBlocks", () => {
-  test("parses TypeScript file blocks with common fence variants", () => {
-    const writes = parseTypescriptFileBlocks(`
-\`\`\`ts
-
-// File: lib/car/car.constant.ts
-
-export const car = "car";
-\`\`\`
-
-\`\`\`tsx
-  // File: lib/car/Car.Unit.tsx
-export const CarUnit = () => null;
-\`\`\`
-`);
-
-    expect(writes).toEqual([
-      {
-        filePath: "lib/car/car.constant.ts",
-        content: 'export const car = "car";',
-      },
-      {
-        filePath: "lib/car/Car.Unit.tsx",
-        content: "export const CarUnit = () => null;",
-      },
-    ]);
-  });
-
-  test("keeps previous code response when validation responds with prose only", () => {
-    const previousContent = `
-\`\`\`typescript
-// File: lib/car/car.constant.ts
-export const car = "car";
-\`\`\`
-`;
-    const nextContent = "The generated file meets all specified requirements. No rewrite is necessary.";
-
-    expect(preserveTypescriptResponseContent(previousContent, nextContent)).toBe(previousContent);
-  });
-
-  test("uses next code response when validation rewrites with parseable files", () => {
-    const previousContent = `
-\`\`\`typescript
-// File: lib/car/car.constant.ts
-export const car = "car";
-\`\`\`
-`;
-    const nextContent = `
-\`\`\`typescript
-// File: lib/car/car.constant.ts
-export const car = "updated";
-\`\`\`
-`;
-
-    expect(preserveTypescriptResponseContent(previousContent, nextContent)).toBe(nextContent);
-  });
-});