Add as-lan as a built-in SDK

.gitignore

@@ -56,3 +56,6 @@ bun.lockb
 
 # e2e test temporary directory
 .test
+
+# Internal planning artifacts (specs/plans for in-progress work)
+docs/superpowers/

AGENTS.md

@@ -62,6 +62,8 @@ bun test bin/cli/src/commands/create-command.test.ts  # Run specific test file
 bun test --watch                                    # Run tests in watch mode
 ```
 
+> **Heads-up for SDK changes.** The `@fluffylabs/jammin-sdk` package is published from `packages/jammin-sdk/dist/`, and CLI tests import it via the package name. After editing files under `packages/jammin-sdk/`, run `bun run build` before `bun test` so test imports see the new symbols. CI runs `bun run build` before `bun test` automatically; the manual step is only needed locally.
+
 ## Code Style & Conventions
 
 ### Linting & Formatting (Biome)

bin/cli/src/commands/build-command.test.ts

@@ -78,6 +78,27 @@ describe("build-command", () => {
       expect(dockerCommand).toContain(`${resolve("/test/project", "./jade")}:/app`);
     });
 
+    test("should generate correct Docker command for as-lan alias", async () => {
+      const service: ServiceConfig = {
+        name: "as-lan-service",
+        path: "./services/example",
+        sdk: "as-lan",
+      };
+
+      await callDockerBuild(service, "/test/project");
+
+      expect(mockSpawn).toHaveBeenCalledTimes(1);
+      const spawnCall = mockSpawn.mock.calls[0];
+      if (!spawnCall) {
+        throw new Error("spawnCall is undefined");
+      }
+      const dockerCommand = spawnCall[0][2] as string;
+
+      expect(dockerCommand).toContain(SDK_CONFIGS["aslan-0.0.4"].image);
+      expect(dockerCommand).toContain(SDK_CONFIGS["aslan-0.0.4"].build);
+      expect(dockerCommand).toContain(`${resolve("/test/project", "./services/example")}:/app`);
+    });
+
     test("should generate correct Docker command for custom SDK config", async () => {
       const customSdk: SdkConfig = {
         image: "custom-image:latest",
@@ -132,8 +153,22 @@ describe("build-command", () => {
         sdk: "jambrains-1cfc41c",
       };
 
-      expect(callDockerBuild(service, "/test/project")).rejects.toThrow();
-      expect(callDockerBuild(service, "/test/project")).rejects.toThrow("Build failed for service 'failing-service'");
+      await expect(callDockerBuild(service, "/test/project")).rejects.toThrow(
+        "Build failed for service 'failing-service'",
+      );
+    });
+
+    test("should throw with descriptive message when SDK id is unknown", async () => {
+      const service: ServiceConfig = {
+        name: "broken-service",
+        path: "./broken",
+        // biome-ignore lint/suspicious/noExplicitAny: simulating a stale config that bypassed validation
+        sdk: "definitely-not-a-real-sdk" as any,
+      };
+
+      await expect(callDockerBuild(service, "/test/project")).rejects.toThrow(
+        "Unknown SDK id: 'definitely-not-a-real-sdk'",
+      );
     });
 
     test("should return build output on success", async () => {

bin/cli/src/commands/build-command.ts

@@ -8,7 +8,7 @@ import {
   getJamFiles,
   getServiceConfigs,
   loadServices,
-  SDK_CONFIGS,
+  resolveSdk,
 } from "@fluffylabs/jammin-sdk";
 import { Command } from "commander";
 
@@ -25,7 +25,7 @@ export class DockerError extends Error {
 }
 
 export async function callDockerBuild(service: ServiceConfig, projectRoot: string): Promise<string> {
-  const sdk = typeof service.sdk === "string" ? SDK_CONFIGS[service.sdk] : service.sdk;
+  const sdk = resolveSdk(service.sdk);
   const servicePath = resolve(projectRoot, service.path);
 
   const dockerArgs = ["run", "--rm", "-v", `${servicePath}:/app`, sdk.image, ...sdk.build.split(" ")];

bin/cli/src/commands/create-command.ts

@@ -2,14 +2,15 @@ import * as p from "@clack/prompts";
 import { fetchRepo, updatePackageJson } from "@fluffylabs/jammin-sdk";
 import { Command, InvalidArgumentError } from "commander";
 
-type Template = "jam-sdk" | "jade" | "jambrains" | "ajanta" | "jamc3" | "undecided";
+type Template = "jam-sdk" | "jade" | "jambrains" | "ajanta" | "jamc3" | "aslan" | "undecided";
 
 const TARGETS: Record<Template, string> = {
   "jam-sdk": "jammin-create/jammin-create-jam-sdk",
   jade: "jammin-create/jammin-create-jade",
   jambrains: "jammin-create/jammin-create-jambrains",
   ajanta: "jammin-create/jammin-create-ajanta",
   jamc3: "jammin-create/jammin-create-jamc3",
+  aslan: "jammin-create/jammin-create-aslan",
   undecided: "jammin-create/jammin-create-undecided",
 };
 

bin/cli/src/commands/test-command.test.ts

@@ -0,0 +1,262 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { resolve } from "node:path";
+import { SDK_CONFIGS, type SdkConfig, type ServiceConfig } from "@fluffylabs/jammin-sdk";
+import { testService } from "./test-command";
+
+describe("test-command", () => {
+  describe("testService - Docker command generation", () => {
+    let originalSpawn: typeof Bun.spawn;
+    let mockSpawn: ReturnType<typeof mock>;
+
+    beforeEach(() => {
+      originalSpawn = Bun.spawn;
+      mockSpawn = mock(() => {
+        return {
+          stdout: new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode("test output"));
+              controller.close();
+            },
+          }),
+          stderr: new ReadableStream({
+            start(controller) {
+              controller.close();
+            },
+          }),
+          exited: Promise.resolve(0),
+        };
+      });
+      // biome-ignore lint/suspicious/noExplicitAny: Need to mock Bun.spawn for testing
+      (Bun as any).spawn = mockSpawn;
+    });
+
+    afterEach(() => {
+      Bun.spawn = originalSpawn;
+    });
+
+    test("should generate correct Docker command for predefined SDK (jambrains)", async () => {
+      const service: ServiceConfig = {
+        name: "test-service",
+        path: "./services/test",
+        sdk: "jambrains-1cfc41c",
+      };
+
+      await testService(service, "/test/project");
+
+      expect(mockSpawn).toHaveBeenCalledTimes(1);
+      const spawnCall = mockSpawn.mock.calls[0];
+      if (!spawnCall) {
+        throw new Error("spawnCall is undefined");
+      }
+      expect(spawnCall[0]).toEqual(["sh", "-c", expect.stringContaining("docker")]);
+
+      const dockerCommand = spawnCall[0][2] as string;
+      expect(dockerCommand).toContain("docker run --rm -v");
+      expect(dockerCommand).toContain(`${resolve("/test/project", "./services/test")}:/app`);
+      expect(dockerCommand).toContain(SDK_CONFIGS["jambrains-1cfc41c"].image);
+      expect(dockerCommand).toContain(SDK_CONFIGS["jambrains-1cfc41c"].test);
+    });
+
+    test("should generate correct Docker command for predefined SDK (jade)", async () => {
+      const service: ServiceConfig = {
+        name: "jade-service",
+        path: "./jade",
+        sdk: "jade-0.0.15-pre.1",
+      };
+
+      await testService(service, "/test/project");
+
+      expect(mockSpawn).toHaveBeenCalledTimes(1);
+      const spawnCall = mockSpawn.mock.calls[0];
+      if (!spawnCall) {
+        throw new Error("spawnCall is undefined");
+      }
+      const dockerCommand = spawnCall[0][2] as string;
+
+      expect(dockerCommand).toContain(SDK_CONFIGS["jade-0.0.15-pre.1"].image);
+      expect(dockerCommand).toContain(SDK_CONFIGS["jade-0.0.15-pre.1"].test);
+      expect(dockerCommand).toContain(`${resolve("/test/project", "./jade")}:/app`);
+    });
+
+    test("should generate correct Docker command for as-lan alias", async () => {
+      const service: ServiceConfig = {
+        name: "as-lan-service",
+        path: "./services/example",
+        sdk: "as-lan",
+      };
+
+      await testService(service, "/test/project");
+
+      expect(mockSpawn).toHaveBeenCalledTimes(1);
+      const spawnCall = mockSpawn.mock.calls[0];
+      if (!spawnCall) {
+        throw new Error("spawnCall is undefined");
+      }
+      const dockerCommand = spawnCall[0][2] as string;
+
+      expect(dockerCommand).toContain(SDK_CONFIGS["aslan-0.0.4"].image);
+      expect(dockerCommand).toContain(SDK_CONFIGS["aslan-0.0.4"].test);
+      expect(dockerCommand).toContain(`${resolve("/test/project", "./services/example")}:/app`);
+    });
+
+    test("should generate correct Docker command for custom SDK config", async () => {
+      const customSdk: SdkConfig = {
+        image: "custom-image:latest",
+        build: "custom build command with args",
+        test: "custom test command",
+      };
+
+      const service: ServiceConfig = {
+        name: "custom-service",
+        path: "./custom",
+        sdk: customSdk,
+      };
+
+      await testService(service, "/test/project");
+
+      expect(mockSpawn).toHaveBeenCalledTimes(1);
+      const spawnCall = mockSpawn.mock.calls[0];
+      if (!spawnCall) {
+        throw new Error("spawnCall is undefined");
+      }
+      const dockerCommand = spawnCall[0][2] as string;
+
+      expect(dockerCommand).toContain("custom-image:latest");
+      expect(dockerCommand).toContain("custom test command");
+      expect(dockerCommand).toContain(`${resolve("/test/project", "./custom")}:/app`);
+    });
+
+    test("should handle test failure with non-zero exit code", async () => {
+      const mockFailedSpawn = mock(() => {
+        return {
+          stdout: new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode("test error output"));
+              controller.close();
+            },
+          }),
+          stderr: new ReadableStream({
+            start(controller) {
+              controller.close();
+            },
+          }),
+          exited: Promise.resolve(1),
+        };
+      });
+
+      // biome-ignore lint/suspicious/noExplicitAny: Need to mock Bun.spawn for testing
+      (Bun as any).spawn = mockFailedSpawn;
+
+      const service: ServiceConfig = {
+        name: "failing-service",
+        path: "./fail",
+        sdk: "jambrains-1cfc41c",
+      };
+
+      await expect(testService(service, "/test/project")).rejects.toThrow("Tests failed for service 'failing-service'");
+    });
+
+    test("should throw with descriptive message when SDK id is unknown", async () => {
+      const service: ServiceConfig = {
+        name: "broken-service",
+        path: "./broken",
+        // biome-ignore lint/suspicious/noExplicitAny: simulating a stale config that bypassed validation
+        sdk: "definitely-not-a-real-sdk" as any,
+      };
+
+      await expect(testService(service, "/test/project")).rejects.toThrow(
+        "Unknown SDK id: 'definitely-not-a-real-sdk'",
+      );
+    });
+
+    test("should return test output on success", async () => {
+      const expectedOutput = "test successful output";
+      const mockSuccessSpawn = mock(() => {
+        return {
+          stdout: new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode(expectedOutput));
+              controller.close();
+            },
+          }),
+          stderr: new ReadableStream({
+            start(controller) {
+              controller.close();
+            },
+          }),
+          exited: Promise.resolve(0),
+        };
+      });
+
+      // biome-ignore lint/suspicious/noExplicitAny: Need to mock Bun.spawn for testing
+      (Bun as any).spawn = mockSuccessSpawn;
+
+      const service: ServiceConfig = {
+        name: "success-service",
+        path: "./success",
+        sdk: "jambrains-1cfc41c",
+      };
+
+      const output = await testService(service, "/test/project");
+      expect(output).toBe(expectedOutput);
+    });
+  });
+
+  describe("testService - service path resolution", () => {
+    let originalSpawn: typeof Bun.spawn;
+
+    beforeEach(() => {
+      originalSpawn = Bun.spawn;
+    });
+
+    afterEach(() => {
+      Bun.spawn = originalSpawn;
+    });
+
+    test("should resolve relative service paths correctly", async () => {
+      const mockSpawn = mock(() => {
+        return {
+          stdout: new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode("test output"));
+              controller.close();
+            },
+          }),
+          stderr: new ReadableStream({
+            start(controller) {
+              controller.close();
+            },
+          }),
+          exited: Promise.resolve(0),
+        };
+      });
+
+      // biome-ignore lint/suspicious/noExplicitAny: Need to mock Bun.spawn for testing
+      (Bun as any).spawn = mockSpawn;
+
+      const service: ServiceConfig = {
+        name: "test-service",
+        path: "./services/test",
+        sdk: "jambrains-1cfc41c",
+      };
+
+      const projectRoot = "/absolute/project/root";
+      await testService(service, projectRoot);
+
+      expect(mockSpawn).toHaveBeenCalledTimes(1);
+      expect(mockSpawn.mock.calls.length).toBeGreaterThan(0);
+      const spawnCall = mockSpawn.mock.calls[0];
+      if (!spawnCall || spawnCall.length === 0) {
+        throw new Error("spawnCall is undefined or empty");
+      }
+      const spawnArgs = (spawnCall as unknown[])[0] as string[];
+      if (!spawnArgs || spawnArgs.length < 3) {
+        throw new Error("spawnArgs is invalid");
+      }
+      const dockerCommand = spawnArgs[2] as string;
+      const expectedPath = resolve(projectRoot, service.path);
+
+      expect(dockerCommand).toContain(`${expectedPath}:/app`);
+    });
+  });
+});

bin/cli/src/commands/test-command.ts

@@ -2,7 +2,7 @@ import { mkdir } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import * as p from "@clack/prompts";
 import type { ServiceConfig } from "@fluffylabs/jammin-sdk";
-import { getServiceConfigs, SDK_CONFIGS } from "@fluffylabs/jammin-sdk";
+import { getServiceConfigs, resolveSdk } from "@fluffylabs/jammin-sdk";
 import { Command } from "commander";
 
 export class DockerError extends Error {
@@ -18,7 +18,7 @@ export class DockerError extends Error {
  * Test a single service using Docker
  */
 export async function testService(service: ServiceConfig, projectRoot: string): Promise<string> {
-  const sdk = typeof service.sdk === "string" ? SDK_CONFIGS[service.sdk] : service.sdk;
+  const sdk = resolveSdk(service.sdk);
   const servicePath = resolve(projectRoot, service.path);
 
   const dockerArgs = ["run", "--rm", "-v", `${servicePath}:/app`, sdk.image, ...sdk.test.split(" ")];

docs/src/getting-started.md

@@ -45,6 +45,9 @@ The interactive wizard will ask you:
    - `jam-sdk` - JAM SDK template for building JAM services
    - `jade` - JADE SDK template
    - `jambrains` - JamBrains SDK template
+   - `ajanta` - Ajanta (Python) SDK template
+   - `jamc3` - JAMC3 (C3) SDK template
+   - `aslan` - as-lan (AssemblyScript) SDK template
    - `undecided` - Starter template for exploring options with all of the above
 
 ### Command-line mode