@akanjs/cli 3.0.0-beta.3 → 3.0.0-beta.30

package/README.md

@@ -74,6 +74,9 @@ artifact is built last and is not overwritten by the root `akan` bootstrap scrip
 - Use `@akanjs/cli` as the user-facing executable package.
 - `@akanjs/devkit` is bundled into the CLI for published CLI usage; it is not required as a separate
   runtime dependency for ordinary CLI users.
+- The `akan code` agent follows that same split: its engine, tools and skills are a devkit facet
+  (`@akanjs/devkit/codeAgent`), and `@akanjs/cli/code` is the terminal host plus the SDK entry that
+  re-exports both.
 
 ## Requirements
 

package/TunnelShare-cwh9ezsm.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  TunnelShare2
+} from "./index-2wc41k5w.js";
+import"./index-94s080qm.js";
+import"./index-52w0fvh8.js";
+export {
+  TunnelShare2 as TunnelShare
+};

package/{agent.command-d2gfxfck.js → agent.command-c4v7kjff.js}

@@ -2,17 +2,16 @@
 import {
   Workspace,
   command
-} from "./index-mak3cd28.js";
-import"./index-q0y2jq9j.js";
-import"./index-2tv3fdx4.js";
-import"./index-6wwzs1bc.js";
-import"./index-by5gpp8x.js";
-import"./index-gyd220p2.js";
-import"./index-ktb5njgy.js";
-import"./index-h7yw2z9n.js";
+} from "./index-xb7qhxa8.js";
+import"./index-52w0fvh8.js";
+import"./index-n3jk2501.js";
+import"./index-hj6w4ka1.js";
+import"./index-hmdq5pqm.js";
+import"./index-tzc1gtrg.js";
+import"./index-zzvvc845.js";
 import {
   AgentScript
-} from "./index-ne2qy0nk.js";
+} from "./index-bxmejydw.js";
 
 // pkgs/@akanjs/cli/agent/agent.command.ts
 class AgentCommand extends command("agent", [AgentScript], ({ public: target }) => ({

package/akanCode.js

@@ -0,0 +1,102 @@
+// @bun
+import {
+  AkanEditScope2,
+  DevLogFeedback2,
+  PreviewChrome2,
+  PreviewView2,
+  PreviewFeedback2,
+  TurnFeedback2,
+  AkanCli2,
+  AkanVerifier2,
+  VerifyFeedback2,
+  AkanToolPack2,
+  MailToolPack2,
+  McpUnauthorized2,
+  McpClient2,
+  McpToolPack2,
+  SessionToolPack2,
+  WebToolPack2,
+  AkanCodePlugins2,
+  AkanEnvKeys2,
+  akanSystemPrompt2,
+  CodeSessionIndex2,
+  AkanCodeServices2,
+  CodeAgentAsks2,
+  CodeAgentEventMapper2,
+  CodeAgentGate2,
+  CodeAgentUi2,
+  CodeMailbox2,
+  CodeSessionFork2,
+  CodeAgent2
+} from "./index-mk3b9rk1.js";
+import {
+  akanCodeDefaultModel2,
+  akanCodeModel2,
+  akanCodeModelSupportsImages2,
+  akanCodeModelWarnings2,
+  CodeAgentStreamPrinter2
+} from "./index-c6eggbee.js";
+import {
+  SubagentPool2,
+  akanCodePaths2
+} from "./index-8tv7356t.js";
+import"./index-7md2g9vw.js";
+import {
+  CodeAgentRpcHost2
+} from "./index-d2242ksy.js";
+import {
+  CodeTuiLines2,
+  CodeTuiAgents2,
+  CodeTuiClipboard2,
+  CodeTuiCommands2,
+  CodeTuiEditor2,
+  CodeTuiFiles2,
+  CodeTuiMarkdown2,
+  CodeTuiParts2
+} from "./index-wa5jbxj1.js";
+export {
+  AkanCli2 as AkanCli,
+  AkanCodePlugins2 as AkanCodePlugins,
+  AkanCodeServices2 as AkanCodeServices,
+  AkanEditScope2 as AkanEditScope,
+  AkanEnvKeys2 as AkanEnvKeys,
+  AkanToolPack2 as AkanToolPack,
+  AkanVerifier2 as AkanVerifier,
+  CodeAgent2 as CodeAgent,
+  CodeAgentAsks2 as CodeAgentAsks,
+  CodeAgentEventMapper2 as CodeAgentEventMapper,
+  CodeAgentGate2 as CodeAgentGate,
+  CodeAgentRpcHost2 as CodeAgentRpcHost,
+  CodeAgentStreamPrinter2 as CodeAgentStreamPrinter,
+  CodeAgentUi2 as CodeAgentUi,
+  CodeMailbox2 as CodeMailbox,
+  CodeSessionFork2 as CodeSessionFork,
+  CodeSessionIndex2 as CodeSessionIndex,
+  CodeTuiAgents2 as CodeTuiAgents,
+  CodeTuiClipboard2 as CodeTuiClipboard,
+  CodeTuiCommands2 as CodeTuiCommands,
+  CodeTuiEditor2 as CodeTuiEditor,
+  CodeTuiFiles2 as CodeTuiFiles,
+  CodeTuiLines2 as CodeTuiLines,
+  CodeTuiMarkdown2 as CodeTuiMarkdown,
+  CodeTuiParts2 as CodeTuiParts,
+  DevLogFeedback2 as DevLogFeedback,
+  MailToolPack2 as MailToolPack,
+  McpClient2 as McpClient,
+  McpToolPack2 as McpToolPack,
+  McpUnauthorized2 as McpUnauthorized,
+  PreviewChrome2 as PreviewChrome,
+  PreviewFeedback2 as PreviewFeedback,
+  PreviewView2 as PreviewView,
+  SessionToolPack2 as SessionToolPack,
+  SubagentPool2 as SubagentPool,
+  TurnFeedback2 as TurnFeedback,
+  VerifyFeedback2 as VerifyFeedback,
+  WebToolPack2 as WebToolPack,
+  akanCodeDefaultModel2 as akanCodeDefaultModel,
+  akanCodeModel2 as akanCodeModel,
+  akanCodeModelSupportsImages2 as akanCodeModelSupportsImages,
+  akanCodeModelWarnings2 as akanCodeModelWarnings,
+  akanCodePaths2 as akanCodePaths,
+  akanSystemPrompt2 as akanSystemPrompt
+};

package/application.command-yzsswrz6.js

@@ -0,0 +1,241 @@
+// @bun
+import {
+  App,
+  Apps,
+  Sys,
+  Exec,
+  Workspace,
+  command
+} from "./index-xb7qhxa8.js";
+import"./index-52w0fvh8.js";
+import"./index-n3jk2501.js";
+import {
+  getMobileTargetChoices
+} from "./index-kb16nzyt.js";
+import"./index-48k96p55.js";
+import"./index-gxamdf18.js";
+import {
+  ApplicationScript
+} from "./index-3rh7thcx.js";
+import"./index-7md2g9vw.js";
+import"./index-35mmm9ca.js";
+
+// pkgs/@akanjs/cli/application/application.command.ts
+var mobileTargetOption = {
+  desc: "native target name (a key of native.targets) or all",
+  ask: "Select native target",
+  enum: async ({ app }) => await getMobileTargetChoices(app)
+};
+var deviceOption = {
+  desc: "simulator, emulator or device to run on: its id or name (e.g. 'iPhone 17' or 'Pixel_10')",
+  default: ""
+};
+var teamOption = { flag: "T", desc: "Apple team id the signing is narrowed to", default: "" };
+var devEnvs = ["local", "debug", "develop", "main"];
+var buildEnvOption = { enum: devEnvs, desc: "backend environment", default: "debug" };
+var startEnvOption = {
+  enum: devEnvs,
+  desc: "backend environment of a --release build; a dev build follows `akan start`, which keeps its own",
+  default: "local"
+};
+var releaseEnvOption = {
+  enum: ["debug", "develop", "main", "local"],
+  desc: "backend environment",
+  default: "main"
+};
+
+class ApplicationCommand extends command("application", [ApplicationScript], ({ public: target }) => ({
+  createApplication: target({ desc: "Create a new application in the workspace" }).arg("appName", String, { desc: "name of application" }).option("start", Boolean, { desc: "start application", default: false }).with(Workspace).exec(async function(appName, start, workspace) {
+    await this.applicationScript.createApplication(appName.toLowerCase().replace(/ /g, "-"), workspace, { start });
+  }),
+  removeApplication: target({ desc: "Remove an application from the workspace" }).with(App).exec(async function(app) {
+    await this.applicationScript.removeApplication(app);
+  }),
+  planSlice: target({ desc: "List the exact files an app needs to live in a workspace of its own" }).with(App).option("format", String, { desc: "output format", default: "text", enum: ["text", "json"] }).exec(async function(app, format) {
+    await this.applicationScript.planSlice(app, format);
+  }),
+  sync: target({ desc: "Sync dependencies and configuration for an app or library" }).with(Sys).exec(async function(sys) {
+    await this.applicationScript.sync(sys);
+  }),
+  script: target({ desc: "Run a custom script in the application" }).with(App).arg("filename", String, { desc: "name of script", nullable: true }).exec(async function(app, filename) {
+    await this.applicationScript.script(app, filename);
+  }),
+  console: target({ desc: "Open an interactive server console for the application" }).with(App).exec(async function(app) {
+    await this.applicationScript.console(app);
+  }),
+  logs: target({ desc: "Tail the running application's logs, filtered (attaches to akan-control.sock)" }).with(App).option("level", String, { desc: "minimum level: trace, verbose, debug, info, warn, error", nullable: true }).option("grep", String, { desc: "substring the message must contain", nullable: true }).option("endpoint", String, {
+    desc: "endpoint glob(s), comma-separated: mutation:*, query:userList",
+    nullable: true
+  }).option("trace", String, { desc: "one request's traceId", nullable: true }).option("child", String, { desc: "replica index(es), comma-separated", nullable: true }).option("role", String, {
+    flag: "R",
+    desc: "process role(s): gateway, federation, batch, all, rsc-worker",
+    nullable: true
+  }).option("origin", String, { desc: "call origin(s): http, websocket, mcp, internal, page", nullable: true }).option("since", String, {
+    desc: "only records newer than this: a duration ago in ms, s, m, h or d (30s, 5m, 2h), or an epoch-ms timestamp",
+    nullable: true
+  }).option("replay", Number, { flag: "n", desc: "records to replay from the buffer before following", default: 0 }).option("json", Boolean, { desc: "print NDJSON records instead of rendered lines", default: false }).option("follow", Boolean, { desc: "keep streaming; pass --follow false for history only", default: true }).option("runtimeDir", String, {
+    flag: "d",
+    desc: "runtime dir holding akan-control.sock (default: local/apps/<app>/runtime)",
+    nullable: true
+  }).exec(async function(app, level, grep, endpoint, trace, child, role, origin, since, replay, json, follow, runtimeDir) {
+    await this.applicationScript.logs(app, {
+      level,
+      grep,
+      endpoint,
+      trace,
+      child,
+      role,
+      origin,
+      since,
+      replay,
+      json,
+      follow,
+      runtimeDir
+    });
+  }),
+  build: target({ short: true, desc: "Build the application for production (frontend + backend)" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("fast", Boolean, { desc: "fast build", default: false }).option("quiet", Boolean, { desc: "hide build progress output", default: false }).exec(async function(app, write, fast, quiet) {
+    await this.applicationScript.build(app, { write, fast, quiet });
+  }),
+  typecheck: target({ short: true, desc: "Typecheck the application" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("clean", Boolean, { desc: "clear typecheck cache before running", default: false }).option("incremental", Boolean, { desc: "reuse TypeScript incremental cache", default: true }).exec(async function(app, write, clean, incremental) {
+    await this.applicationScript.typecheck(app, { write, clean, incremental });
+  }),
+  test: target({ desc: "Prepare and test an app, library, or package" }).with(Exec).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(exec, write) {
+    await this.applicationScript.test(exec, { write });
+  }),
+  buildIos: target({ short: true, desc: "Build the iOS app on the native runtime" }).with(App).option("target", String, mobileTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, write) {
+    await this.applicationScript.buildIos(app, { target, env, profile: debug ? "debug" : "release", write });
+  }),
+  buildAndroid: target({ short: true, desc: "Build the Android app (apk) on the native runtime" }).with(App).option("target", String, mobileTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, write) {
+    await this.applicationScript.buildAndroid(app, { target, env, profile: debug ? "debug" : "release", write });
+  }),
+  buildDesktop: target({ short: true, desc: "Build the desktop app for this computer (macOS, Windows or Linux)" }).with(App).option("target", String, mobileTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("installer", Boolean, {
+    desc: "Windows: also an NSIS setup program (per user, /S for a silent install)",
+    default: false
+  }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, installer, write) {
+    await this.applicationScript.buildDesktop(app, {
+      target,
+      env,
+      profile: debug ? "debug" : "release",
+      installer,
+      write
+    });
+  }),
+  start: target({ short: true, desc: "Start development server(s) (frontend SSR + backend)" }).with(Apps).option("plain", Boolean, { desc: "print prefixed lines instead of the full-screen view", default: false }).option("kill", Boolean, { flag: "k", desc: "free the dev ports first, whoever is holding them", default: false }).option("concurrency", Number, {
+    desc: "apps to boot at a time (default: what this machine's memory and cores allow)",
+    nullable: true
+  }).option("dbup", Boolean, { desc: "start the local database first", default: true }).option("open", Boolean, { desc: "open web browser?", default: false }).option("share", Boolean, { desc: "also share each app on a public URL through an akan tunnel", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(apps, plain, kill, concurrency, dbup, open, share, write) {
+    await this.applicationScript.start(apps, { plain, kill, concurrency, dbup, open, share, write });
+  }),
+  startIos: target({ short: true, desc: "Run the iOS app in a simulator or on an iPhone, following `akan start`" }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("device", String, deviceOption).option("team", String, teamOption).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, device, team, write) {
+    await this.applicationScript.startIos(app, {
+      target,
+      env,
+      operation: release ? "release" : "local",
+      device: device || undefined,
+      teamId: team || undefined,
+      write
+    });
+  }),
+  startAndroid: target({
+    short: true,
+    desc: "Run the Android app in an emulator or on a device, following `akan start`"
+  }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("device", String, deviceOption).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, device, write) {
+    await this.applicationScript.startAndroid(app, {
+      target,
+      env,
+      operation: release ? "release" : "local",
+      device: device || undefined,
+      write
+    });
+  }),
+  startDesktop: target({
+    short: true,
+    desc: "Run the desktop app on this computer (macOS, Windows or Linux), following `akan start`"
+  }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, write) {
+    await this.applicationScript.startDesktop(app, {
+      target,
+      env,
+      operation: release ? "release" : "local",
+      write
+    });
+  }),
+  releaseIos: target({ desc: "Build and sign the iOS app for the App Store (.ipa)" }).with(App).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("team", String, teamOption).option("adHoc", Boolean, { desc: "sign with an ad-hoc profile instead of app-store", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, target, env, team, adHoc, write, allowLocalRelease) {
+    await this.applicationScript.releaseIos(app, {
+      target,
+      env,
+      teamId: team || undefined,
+      adHoc,
+      write,
+      allowLocalRelease
+    });
+  }),
+  releaseAndroid: target({ desc: "Build and sign the Android app for the Play Store (aab, or apk)" }).with(App).option("assembleType", String, { enum: ["aab", "apk"], default: "aab" }).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, assembleType, target, env, write, allowLocalRelease) {
+    await this.applicationScript.releaseAndroid(app, assembleType, {
+      target,
+      env,
+      write,
+      allowLocalRelease
+    });
+  }),
+  packUpdate: target({
+    desc: "Pack an unsigned over-the-air update of the mobile web bundle, for the signer to publish"
+  }).with(App).option("platform", String, { enum: ["ios", "android"], desc: "the app it updates" }).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("out", String, {
+    desc: "output folder (default: .akan/native/<target>/updates/<platform>)",
+    nullable: true
+  }).option("against", String, {
+    desc: "bundle.json of the store build it must run in; fails when it needs a new one",
+    nullable: true
+  }).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow packing with --env local", default: false }).exec(async function(app, platform, target, env, out, against, write, allowLocalRelease) {
+    await this.applicationScript.packUpdate(app, platform, {
+      target,
+      env,
+      out: out ?? undefined,
+      against: against ?? undefined,
+      write,
+      allowLocalRelease
+    });
+  }),
+  updateKeygen: target({ desc: "Make (once) the key an app's update releases are signed with; print its public key" }).with(App).option("platform", String, {
+    enum: ["desktop", "android", "ios"],
+    default: "desktop",
+    desc: "the platform whose app id the key signs for (an appId may differ per platform)"
+  }).option("target", String, mobileTargetOption).exec(async function(app, platform, target) {
+    await this.applicationScript.updateKeygen(app, platform, { target });
+  }),
+  publishUpdate: target({ desc: "Build and sign an update release installed apps take (desktop, android or ios)" }).with(App).option("platform", String, {
+    enum: ["desktop", "android", "ios"],
+    default: "desktop",
+    desc: "desktop is this computer's OS and CPU; android and ios publish the web bundle"
+  }).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("channel", String, {
+    desc: "the manifest to publish to (default: the target's updates.channel, else --env)",
+    nullable: true
+  }).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, platform, target, env, channel, write, allowLocalRelease) {
+    await this.applicationScript.publishUpdate(app, platform, {
+      target,
+      env,
+      ...channel ? { channel } : {},
+      write,
+      allowLocalRelease
+    });
+  }),
+  dbup: target({ desc: "Start local database services for a database mode" }).with(Workspace).option("mode", String, {
+    desc: "database mode; left out, every mode the workspace's apps declare",
+    enum: ["single", "multiple", "cluster"],
+    nullable: true
+  }).exec(async function(workspace, mode) {
+    await this.applicationScript.dbupDeclared(workspace, mode);
+  }),
+  dbExport: target({ desc: "Write every model table of an app to one NDJSON file each" }).with(App).option("dir", String, { desc: "directory under the workspace to write", default: "local/transfer" }).exec(async function(app, dir) {
+    await this.applicationScript.transferDatabase(app, "export", dir);
+  }),
+  dbImport: target({ desc: "Read files db-export wrote into an app's database, in the mode the shell names" }).with(App).option("dir", String, { desc: "directory under the workspace to read", default: "local/transfer" }).exec(async function(app, dir) {
+    await this.applicationScript.transferDatabase(app, "import", dir);
+  }),
+  dbdown: target({ desc: "Stop local database services" }).with(Workspace).exec(async function(workspace) {
+    await this.applicationScript.dbdown(workspace);
+  })
+})) {
+}
+export {
+  ApplicationCommand
+};