@jskit-ai/jskit-cli 0.2.80 → 0.2.82

package/src/server/core/commandCatalog.js

@@ -9,7 +9,9 @@ const OPTION_FLAG_LABELS = Object.freeze({
   checkDiLabels: "--check-di-labels",
   verbose: "--verbose",
   json: "--json",
-  all: "--all"
+  all: "--all",
+  abandoned: "--abandoned",
+  completed: "--completed"
 });
 
 const PARSED_BOOLEAN_OPTION_KEYS = Object.freeze(Object.keys(OPTION_FLAG_LABELS));
@@ -211,15 +213,27 @@ const COMMAND_DESCRIPTORS = Object.freeze({
       }),
       Object.freeze({
         name: "[step|abandon|adopt-codex-thread]",
-        description: "Run the next step, abandon a session, or attach a Codex thread id."
+        description: "Run the next step, inspect a diff, abandon a session, or attach a Codex thread id."
       })
     ]),
     defaults: Object.freeze([
       "Active session state lives in .jskit/sessions/active/<session_id> under the current target app.",
-      "Session worktrees live in .jskit/sessions/worktrees/<session_id>.",
+      "Session worktrees live in .jskit/sessions/active/<session_id>/worktree.",
       "The session id is timestamp-based and is the primary key.",
+      "Bare list output includes active sessions only; use --abandoned, --completed, or --all for archived sessions.",
       "Use --json for the stable machine-readable contract consumed by JSKIT AI Studio.",
-      "Use --issue - to read approved issue text from stdin."
+      "Use --issue - to read approved issue body from stdin.",
+      "Use --issue-title when the approved issue title is separate from the body.",
+      "Use --issue-details - to read confirmed issue details from stdin.",
+      "Use --plan - to read the approved implementation plan from stdin.",
+      "Use --rework-notes - with --user-check failed to start the next plan cycle.",
+      "Use --agent-decisions - to append session-local decision log entries from implementation, UI review, verification, or repair phases.",
+      "Use --review-findings-remaining true --review-findings \"<findings>\" when an accepted review pass needs another pass.",
+      "Use --review-findings-remaining false only when the review/deslop loop is done.",
+      "Use --skip-ui-check --skip-reason \"<reason>\" only when uiImpact is possible and the Deep UI Check is intentionally skipped.",
+      "Use --merge-pr true at PR finalization to merge the pull request.",
+      "Use --close-without-merge --close-reason \"<reason>\" at PR finalization to complete the session without merging.",
+      "Run the blueprint step once to render its Codex prompt, then again after Codex updates .jskit/APP_BLUEPRINT.md."
     ]),
     examples: Object.freeze([
       Object.freeze({
@@ -228,15 +242,26 @@ const COMMAND_DESCRIPTORS = Object.freeze({
           "jskit session create",
           "jskit session 2026-05-11_21-42-08 step",
           "jskit session 2026-05-11_21-42-08 step --prompt \"Fix the customer filters\"",
-          "jskit session 2026-05-11_21-42-08 step --issue -"
+          "jskit session 2026-05-11_21-42-08 step --issue-title \"Fix customer filters\" --issue -",
+          "jskit session 2026-05-11_21-42-08 step --issue-details -",
+          "jskit session 2026-05-11_21-42-08 step --plan -",
+          "jskit session 2026-05-11_21-42-08 step --agent-decisions -",
+          "jskit session 2026-05-11_21-42-08 step --review-findings-remaining true --review-findings \"A helper duplication fix needs another pass\"",
+          "jskit session 2026-05-11_21-42-08 step --review-findings-remaining false",
+          "jskit session 2026-05-11_21-42-08 step --skip-ui-check --skip-reason \"No user-facing UI changes\"",
+          "jskit session 2026-05-11_21-42-08 step",
+          "jskit session 2026-05-11_21-42-08 step --merge-pr true",
+          "jskit session 2026-05-11_21-42-08 step --close-without-merge --close-reason \"Prototype kept for reference\"",
+          "jskit session 2026-05-11_21-42-08 step --user-check failed --rework-notes -",
+          "jskit session 2026-05-11_21-42-08 diff --json"
         ])
       })
     ]),
     fullUse:
-      "jskit session [create|<sessionId>] [step|abandon|adopt-codex-thread] [--prompt <text>] [--issue <text>|--issue-file <path>] [--user-check <passed|failed>] [--codex-thread-id <id>] [--json]",
+      "jskit session [create|<sessionId>] [step|diff|abandon|adopt-codex-thread] [--prompt <text>] [--issue-title <text>|--issue-title-file <path>] [--issue <text>|--issue-file <path>] [--issue-details <text>|--issue-details-file <path>] [--plan <text>|--plan-file <path>] [--agent-decisions <text>|--agent-decisions-file <path>] [--review-findings-remaining true --review-findings <text>|--review-findings-remaining false] [--skip-ui-check --skip-reason <text>] [--merge-pr true|--close-without-merge --close-reason <text>] [--user-check <passed|failed>] [--rework-notes <text>|--rework-notes-file <path>] [--codex-thread-id <id>] [--abandoned|--completed|--all] [--json]",
     showHelpOnBareInvocation: false,
     handlerName: "commandSession",
-    allowedFlagKeys: Object.freeze(["json"]),
+    allowedFlagKeys: Object.freeze(["json", "abandoned", "completed", "all"]),
     inlineOptionMode: "delegate",
     allowedValueOptionNames: Object.freeze([]),
     canDelegateInlineOptions: (positional = []) => Array.isArray(positional) && positional.length > 0
@@ -281,6 +306,44 @@ const COMMAND_DESCRIPTORS = Object.freeze({
       return subcommand === "prompt" || subcommand === "set";
     }
   }),
+  "helper-map": Object.freeze({
+    command: "helper-map",
+    aliases: Object.freeze([]),
+    showInOverview: true,
+    summary: "Read or update the generated app helper map.",
+    minimalUse: "jskit helper-map update",
+    parameters: Object.freeze([
+      Object.freeze({
+        name: "[update]",
+        description: "Without a subcommand, prints the saved helper map. update refreshes .jskit/helper-map files."
+      })
+    ]),
+    defaults: Object.freeze([
+      "The helper map is generated app state, not a hand-maintained workflow file.",
+      "The JSON file lives at .jskit/helper-map.json and the readable map lives at .jskit/helper-map.md.",
+      "Use the map before adding helpers, composables, service functions, maps, or package glue.",
+      "Use --json for a stable machine-readable response."
+    ]),
+    examples: Object.freeze([
+      Object.freeze({
+        label: "Refresh helper map",
+        lines: Object.freeze([
+          "jskit helper-map update",
+          "jskit helper-map --json"
+        ])
+      })
+    ]),
+    fullUse: "jskit helper-map [update] [--json]",
+    showHelpOnBareInvocation: false,
+    handlerName: "commandHelperMap",
+    allowedFlagKeys: Object.freeze(["json"]),
+    inlineOptionMode: "delegate",
+    allowedValueOptionNames: Object.freeze([]),
+    canDelegateInlineOptions: (positional = []) => {
+      const subcommand = String(Array.isArray(positional) ? positional[0] || "" : "").trim();
+      return subcommand === "update";
+    }
+  }),
   add: Object.freeze({
     command: "add",
     aliases: Object.freeze([]),

package/src/server/core/createCommandHandlers.js

@@ -8,6 +8,7 @@ import { createHealthCommands } from "../commandHandlers/health.js";
 import { createCompletionCommands } from "../commandHandlers/completion.js";
 import { createSessionCommands } from "../commandHandlers/session.js";
 import { createBlueprintCommands } from "../commandHandlers/blueprint.js";
+import { createHelperMapCommands } from "../commandHandlers/helperMap.js";
 
 function createCommandHandlers(deps = {}) {
   const shared = createCommandHandlerShared(deps);
@@ -33,6 +34,7 @@ function createCommandHandlers(deps = {}) {
   const { commandCompletion } = createCompletionCommands(commandContext);
   const { commandSession } = createSessionCommands(commandContext);
   const { commandBlueprint } = createBlueprintCommands(commandContext);
+  const { commandHelperMap } = createHelperMapCommands(commandContext);
 
   return {
     commandList,
@@ -52,7 +54,8 @@ function createCommandHandlers(deps = {}) {
     commandDoctor,
     commandLintDescriptors,
     commandSession,
-    commandBlueprint
+    commandBlueprint,
+    commandHelperMap
   };
 }
 

package/src/server/helperMap.js

@@ -0,0 +1,463 @@
+import {
+  mkdir,
+  readFile,
+  readdir,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import path from "node:path";
+import { compileScript, parse as parseVueSfc } from "@vue/compiler-sfc";
+import tsMorph from "ts-morph";
+import {
+  HELPER_MAP_JSON_RELATIVE_PATH,
+  HELPER_MAP_MARKDOWN_RELATIVE_PATH
+} from "./helperMapPaths.js";
+
+const {
+  ModuleKind,
+  ModuleResolutionKind,
+  Project,
+  ScriptTarget
+} = tsMorph;
+
+const HELPER_MAP_SCHEMA_VERSION = 1;
+const CODE_EXTENSIONS = new Set([".cjs", ".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"]);
+const APP_SCAN_ROOTS = Object.freeze(["src", "packages", "config", "server", "scripts"]);
+const EXCLUDED_DIR_NAMES = new Set([
+  ".git",
+  ".jskit",
+  ".npm-cache",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+const HELPER_NAME_PATTERN =
+  /^(assert|build|coerce|create|ensure|extract|format|get|has|is|list|load|make|map|normalize|parse|read|render|resolve|run|serialize|to|update|use|validate|write)[A-Z_]/u;
+
+async function pathExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function readJsonFile(filePath) {
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+
+function normalizePackageDependencies(packageJson = {}) {
+  const dependencies = {
+    ...(packageJson.dependencies || {}),
+    ...(packageJson.devDependencies || {}),
+    ...(packageJson.peerDependencies || {}),
+    ...(packageJson.optionalDependencies || {})
+  };
+  return Object.keys(dependencies).sort((left, right) => left.localeCompare(right));
+}
+
+function classifySymbol(name = "") {
+  if (!name || name === "default") {
+    return "default";
+  }
+  if (/^use[A-Z]/u.test(name)) {
+    return "composable";
+  }
+  if (/^[A-Z]/u.test(name)) {
+    return "component_or_class";
+  }
+  if (HELPER_NAME_PATTERN.test(name)) {
+    return "helper";
+  }
+  return "export";
+}
+
+function createExportAnalysisProject() {
+  return new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      allowJs: true,
+      checkJs: false,
+      module: ModuleKind.ESNext,
+      moduleResolution: ModuleResolutionKind.NodeNext,
+      target: ScriptTarget.ESNext
+    }
+  });
+}
+
+function kindFromDeclaration(declaration, exportName = "") {
+  if (exportName === "default") {
+    return "default";
+  }
+  switch (declaration.getKindName()) {
+    case "ClassDeclaration":
+      return "class";
+    case "EnumDeclaration":
+      return "enum";
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+    case "MethodDeclaration":
+      return "function";
+    case "InterfaceDeclaration":
+      return "interface";
+    case "TypeAliasDeclaration":
+      return "type";
+    case "VariableDeclaration": {
+      const initializer = typeof declaration.getInitializer === "function"
+        ? declaration.getInitializer()
+        : null;
+      const initializerKind = initializer?.getKindName?.() || "";
+      return initializerKind === "ArrowFunction" || initializerKind === "FunctionExpression"
+        ? "function"
+        : "value";
+    }
+    default:
+      return "export";
+  }
+}
+
+function addSymbol(symbols, symbol) {
+  if (!symbol.name) {
+    return;
+  }
+  const key = `${symbol.name}:${symbol.kind}`;
+  if (symbols.has(key)) {
+    return;
+  }
+  symbols.set(key, {
+    name: symbol.name,
+    kind: symbol.kind,
+    role: classifySymbol(symbol.name)
+  });
+}
+
+function extractExportedSymbols(sourceFile) {
+  const symbols = new Map();
+  for (const [name, declarations] of sourceFile.getExportedDeclarations()) {
+    for (const declaration of declarations) {
+      addSymbol(symbols, {
+        name,
+        kind: kindFromDeclaration(declaration, name)
+      });
+    }
+  }
+
+  return [...symbols.values()].sort((left, right) => {
+    const byName = left.name.localeCompare(right.name);
+    return byName || left.kind.localeCompare(right.kind);
+  });
+}
+
+function extractVueScriptSource(source = "", filePath = "") {
+  const parsed = parseVueSfc(source, {
+    filename: filePath
+  });
+  if (parsed.errors.length > 0) {
+    throw new Error(parsed.errors.map((error) => error.message || String(error)).join("; "));
+  }
+  const descriptor = parsed.descriptor;
+  if (descriptor.scriptSetup) {
+    return compileScript(descriptor, {
+      id: filePath
+    }).content;
+  }
+  if (descriptor.script) {
+    return descriptor.script.content;
+  }
+  return "";
+}
+
+async function addCodeFileToProject(project, file) {
+  if (path.extname(file.absolutePath) !== ".vue") {
+    return project.addSourceFileAtPath(file.absolutePath);
+  }
+  const source = extractVueScriptSource(await readFile(file.absolutePath, "utf8"), file.absolutePath);
+  if (!source.trim()) {
+    return null;
+  }
+  return project.createSourceFile(`${file.absolutePath}.ts`, source, {
+    overwrite: true
+  });
+}
+
+async function walkCodeFiles(rootPath, relativeRoot = "") {
+  const entries = await readdir(rootPath, {
+    withFileTypes: true
+  });
+  const files = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (EXCLUDED_DIR_NAMES.has(entry.name)) {
+      continue;
+    }
+    const absolutePath = path.join(rootPath, entry.name);
+    const relativePath = path.join(relativeRoot, entry.name).split(path.sep).join("/");
+    if (entry.isDirectory()) {
+      files.push(...await walkCodeFiles(absolutePath, relativePath));
+      continue;
+    }
+    if (!entry.isFile() || !CODE_EXTENSIONS.has(path.extname(entry.name))) {
+      continue;
+    }
+    files.push({
+      absolutePath,
+      relativePath
+    });
+  }
+  return files;
+}
+
+async function collectAppExports(targetRoot) {
+  const scanFiles = [];
+  for (const scanRoot of APP_SCAN_ROOTS) {
+    const rootPath = path.join(targetRoot, scanRoot);
+    if (await pathExists(rootPath)) {
+      scanFiles.push(...await walkCodeFiles(rootPath, scanRoot));
+    }
+  }
+
+  const project = createExportAnalysisProject();
+  const files = [];
+  for (const file of scanFiles.sort((left, right) => left.relativePath.localeCompare(right.relativePath))) {
+    const sourceFile = await addCodeFileToProject(project, file);
+    if (!sourceFile) {
+      continue;
+    }
+    const symbols = extractExportedSymbols(sourceFile);
+    if (symbols.length === 0) {
+      continue;
+    }
+    files.push({
+      path: file.relativePath,
+      exports: symbols
+    });
+  }
+  return files;
+}
+
+function flattenPackageExports(exportsField) {
+  const targets = new Map();
+
+  function addTarget(subpath, target) {
+    if (!target || target.includes("*")) {
+      return;
+    }
+    targets.set(`${subpath}:${target}`, {
+      subpath,
+      target
+    });
+  }
+
+  function collect(value, subpath = ".") {
+    if (typeof value === "string") {
+      addTarget(subpath, value);
+      return;
+    }
+    if (!value || Array.isArray(value) || typeof value !== "object") {
+      return;
+    }
+    const entries = Object.entries(value);
+    const hasSubpathKeys = entries.some(([key]) => key.startsWith("."));
+    for (const [key, nested] of entries) {
+      if (key.startsWith(".")) {
+        collect(nested, key);
+      } else {
+        collect(nested, hasSubpathKeys ? subpath : subpath || ".");
+      }
+    }
+  }
+
+  collect(exportsField, ".");
+  return [...targets.values()].sort((left, right) => {
+    const bySubpath = left.subpath.localeCompare(right.subpath);
+    return bySubpath || left.target.localeCompare(right.target);
+  });
+}
+
+async function collectJskitPackageExports(targetRoot, packageJson = {}) {
+  const packageNames = normalizePackageDependencies(packageJson)
+    .filter((name) => name.startsWith("@jskit-ai/"));
+  const packages = [];
+  const project = createExportAnalysisProject();
+
+  for (const packageName of packageNames) {
+    const packageRoot = path.join(targetRoot, "node_modules", ...packageName.split("/"));
+    const packageJsonPath = path.join(packageRoot, "package.json");
+    if (!await pathExists(packageJsonPath)) {
+      packages.push({
+        name: packageName,
+        installed: false,
+        exports: []
+      });
+      continue;
+    }
+
+    const installedPackageJson = await readJsonFile(packageJsonPath);
+    const exportTargets = flattenPackageExports(installedPackageJson.exports || {});
+    const exports = [];
+    for (const exportTarget of exportTargets) {
+      const normalizedTarget = exportTarget.target.replace(/^\.\//u, "");
+      const targetPath = path.join(packageRoot, normalizedTarget);
+      const ext = path.extname(targetPath);
+      if (!CODE_EXTENSIONS.has(ext) || !await pathExists(targetPath)) {
+        continue;
+      }
+      const sourceFile = await addCodeFileToProject(project, {
+        absolutePath: targetPath,
+        relativePath: normalizedTarget
+      });
+      exports.push({
+        subpath: exportTarget.subpath,
+        target: normalizedTarget.split(path.sep).join("/"),
+        exports: sourceFile ? extractExportedSymbols(sourceFile) : []
+      });
+    }
+
+    packages.push({
+      name: packageName,
+      version: installedPackageJson.version || "",
+      installed: true,
+      exports
+    });
+  }
+
+  return packages;
+}
+
+function renderExportList(symbols = []) {
+  if (symbols.length === 0) {
+    return "    - no exported symbols detected";
+  }
+  return symbols
+    .map((symbol) => `    - ${symbol.name} (${symbol.kind}, ${symbol.role})`)
+    .join("\n");
+}
+
+function renderHelperMapMarkdown(map) {
+  const lines = [
+    "# JSKIT Helper Map",
+    "",
+    "Generated by `jskit helper-map update`. Read this before adding new helpers, composables, service functions, maps, or package glue.",
+    "",
+    `Root package: ${map.rootPackage.name || "unknown"}`,
+    "",
+    "## App-local exports",
+    ""
+  ];
+
+  if (map.app.files.length === 0) {
+    lines.push("No app-local exported helpers or symbols detected.", "");
+  } else {
+    for (const file of map.app.files) {
+      lines.push(`- ${file.path}`, renderExportList(file.exports), "");
+    }
+  }
+
+  lines.push("## Direct JSKIT package exports", "");
+  if (map.jskitPackages.length === 0) {
+    lines.push("No direct `@jskit-ai/*` dependencies were found.", "");
+  } else {
+    for (const packageEntry of map.jskitPackages) {
+      if (!packageEntry.installed) {
+        lines.push(`- ${packageEntry.name}: not installed in node_modules`, "");
+        continue;
+      }
+      lines.push(`- ${packageEntry.name}@${packageEntry.version || "unknown"}`);
+      if (packageEntry.exports.length === 0) {
+        lines.push("    - no exported code files detected");
+      } else {
+        for (const exportEntry of packageEntry.exports) {
+          lines.push(`    - ${exportEntry.subpath} -> ${exportEntry.target}`);
+          for (const symbol of exportEntry.exports) {
+            lines.push(`      - ${symbol.name} (${symbol.kind}, ${symbol.role})`);
+          }
+        }
+      }
+      lines.push("");
+    }
+  }
+
+  return `${lines.join("\n").replace(/\n{3,}/gu, "\n\n").trimEnd()}\n`;
+}
+
+async function buildHelperMap({ targetRoot }) {
+  const packageJsonPath = path.join(targetRoot, "package.json");
+  const packageJson = await readJsonFile(packageJsonPath);
+  const map = {
+    schemaVersion: HELPER_MAP_SCHEMA_VERSION,
+    generatedBy: "jskit helper-map update",
+    rootPackage: {
+      name: packageJson.name || "",
+      version: packageJson.version || ""
+    },
+    app: {
+      files: await collectAppExports(targetRoot)
+    },
+    jskitPackages: await collectJskitPackageExports(targetRoot, packageJson)
+  };
+  return {
+    ok: true,
+    map,
+    helperMapJsonPath: path.join(targetRoot, HELPER_MAP_JSON_RELATIVE_PATH),
+    helperMapMarkdownPath: path.join(targetRoot, HELPER_MAP_MARKDOWN_RELATIVE_PATH)
+  };
+}
+
+async function readHelperMap({ targetRoot }) {
+  const helperMapJsonPath = path.join(targetRoot, HELPER_MAP_JSON_RELATIVE_PATH);
+  const helperMapMarkdownPath = path.join(targetRoot, HELPER_MAP_MARKDOWN_RELATIVE_PATH);
+  if (!await pathExists(helperMapJsonPath)) {
+    return {
+      ok: true,
+      exists: false,
+      helperMapJsonPath,
+      helperMapMarkdownPath,
+      map: null,
+      markdown: ""
+    };
+  }
+  return {
+    ok: true,
+    exists: true,
+    helperMapJsonPath,
+    helperMapMarkdownPath,
+    map: await readJsonFile(helperMapJsonPath),
+    markdown: await pathExists(helperMapMarkdownPath) ? await readFile(helperMapMarkdownPath, "utf8") : ""
+  };
+}
+
+async function updateHelperMap({ targetRoot }) {
+  const payload = await buildHelperMap({ targetRoot });
+  const markdown = renderHelperMapMarkdown(payload.map);
+  const json = `${JSON.stringify(payload.map, null, 2)}\n`;
+  const currentJson = await pathExists(payload.helperMapJsonPath)
+    ? await readFile(payload.helperMapJsonPath, "utf8")
+    : "";
+  const currentMarkdown = await pathExists(payload.helperMapMarkdownPath)
+    ? await readFile(payload.helperMapMarkdownPath, "utf8")
+    : "";
+  const changed = currentJson !== json || currentMarkdown !== markdown;
+  if (changed) {
+    await mkdir(path.dirname(payload.helperMapJsonPath), {
+      recursive: true
+    });
+    await writeFile(payload.helperMapJsonPath, json, "utf8");
+    await writeFile(payload.helperMapMarkdownPath, markdown, "utf8");
+  }
+  return {
+    ...payload,
+    changed,
+    markdown
+  };
+}
+
+export {
+  HELPER_MAP_JSON_RELATIVE_PATH,
+  HELPER_MAP_MARKDOWN_RELATIVE_PATH,
+  buildHelperMap,
+  readHelperMap,
+  updateHelperMap
+};

package/src/server/helperMapPaths.js

@@ -0,0 +1,7 @@
+const HELPER_MAP_JSON_RELATIVE_PATH = ".jskit/helper-map.json";
+const HELPER_MAP_MARKDOWN_RELATIVE_PATH = ".jskit/helper-map.md";
+
+export {
+  HELPER_MAP_JSON_RELATIVE_PATH,
+  HELPER_MAP_MARKDOWN_RELATIVE_PATH
+};

package/src/server/sessionRuntime/appReadiness.js

@@ -0,0 +1,55 @@
+import { access, stat } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import path from "node:path";
+
+const REQUIRED_READY_FILES = Object.freeze([
+  "package.json",
+  ".jskit/lock.json",
+  "config/public.js"
+]);
+const REQUIRED_READY_DIRECTORIES = Object.freeze([
+  "src",
+  "packages"
+]);
+
+async function pathExists(filePath) {
+  try {
+    await access(filePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function directoryExists(filePath) {
+  try {
+    return (await stat(filePath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function inspectReadyJskitAppRoot(rootPath) {
+  const missing = [];
+  for (const relativePath of REQUIRED_READY_FILES) {
+    if (!await pathExists(path.join(rootPath, relativePath))) {
+      missing.push(relativePath);
+    }
+  }
+  for (const relativePath of REQUIRED_READY_DIRECTORIES) {
+    if (!await directoryExists(path.join(rootPath, relativePath))) {
+      missing.push(`${relativePath}/`);
+    }
+  }
+  return {
+    missing,
+    ok: missing.length < 1,
+    requiredDirectories: [...REQUIRED_READY_DIRECTORIES],
+    requiredFiles: [...REQUIRED_READY_FILES],
+    rootPath
+  };
+}
+
+export {
+  inspectReadyJskitAppRoot
+};