@printpractical/cruze 0.0.1

package/dist/adapters/inbound/cli/commands/progress.js

@@ -0,0 +1,51 @@
+import { addFutureFeature, completeTask, dropFutureFeature, pruneRoadmap, recordDeviation, reopenTask } from "../../../../app/use_cases/record_progress.js";
+import { abandonWork } from "../../../../app/use_cases/abandon_work.js";
+import { UsageError, requireArgs, requireOption,                                                   } from "../cli_context.js";
+
+export async function runTask(context            , args          , options         )                         {
+  requireArgs(args, ["done|deviation|reopen", "task"]);
+  const change = options.change === undefined ? {} : { change: options.change };
+  if (args[0] === "done") {
+    const report = await completeTask(context, args[1] ?? "", { ...change, ...(options.commit === undefined ? {} : { commit: options.commit }) });
+    return { json: report, human: `${report.task} done in ${report.change} (${report.done}/${report.total}).` };
+  }
+  if (args[0] === "deviation") {
+    requireArgs(args, ["deviation", "task", "text"]);
+    const report = await recordDeviation(context, args[1] ?? "", args.slice(2).join(" "), change);
+    return { json: report, human: `Recorded a deviation on ${report.task} in ${report.change}.` };
+  }
+  if (args[0] === "reopen") {
+    requireArgs(args, ["reopen", "task", "reason"]);
+    const report = await reopenTask(context, args[1] ?? "", args.slice(2).join(" "), change);
+    return { json: report, human: `Reopened ${report.task} in ${report.change}.` };
+  }
+  throw new UsageError(`cruze task takes done, deviation or reopen, not "${args[0]}"`);
+}
+
+export async function runFeatures(context            , args          , options         )                         {
+  requireArgs(args, ["add|drop", "slug"]);
+  if (args[0] === "add") {
+    const goals = (options.goals ?? "").split(",").map((g) => g.trim()).filter((g) => g !== "");
+    const report = await addFutureFeature(context, args[1] ?? "", requireOption(options.summary, "--summary"), goals);
+    return { json: report, human: `Added ${report.feature} to the future list.` };
+  }
+  if (args[0] === "drop") {
+    const report = await dropFutureFeature(context, args[1] ?? "", requireOption(options.reason, "--reason"));
+    return { json: report, human: `Dropped ${report.feature} from the future list.` };
+  }
+  throw new UsageError(`cruze features takes add or drop, not "${args[0]}"`);
+}
+
+export async function runRoadmap(context            , args          )                         {
+  requireArgs(args, ["prune"]);
+  if (args[0] !== "prune") throw new UsageError(`cruze roadmap takes prune, not "${args[0]}"`);
+  const report = await pruneRoadmap(context);
+  return { json: report, human: report.removed.length === 0 ? "No landed items to clear." : `Cleared ${report.removed.join(", ")} from the roadmap status.` };
+}
+
+export async function runAbandon(context            , args          , options         )                         {
+  requireArgs(args, ["ref"]);
+  const report = await abandonWork(context, args[0] ?? "", requireOption(options.reason, "--reason"));
+  const back = report.futureList === undefined ? "" : ` ${report.futureList} is back on the future list.`;
+  return { json: report, human: `Abandoned ${report.ref}; archived to ${report.archivedTo}.${back}` };
+}

package/dist/adapters/inbound/cli/commands/review.js

@@ -0,0 +1,18 @@
+import { runReview } from "../../../../app/use_cases/run_review.js";
+import { UsageError, requireArgs,                                                   } from "../cli_context.js";
+
+export async function runReviewCommand(context            , args          , options         )                         {
+  requireArgs(args, ["role"]);
+  const round = options.round === undefined ? undefined : Number(options.round);
+  if (round !== undefined && round !== 1 && round !== 2) throw new UsageError("--round is 1 or 2");
+  const blockers = options.blockers === undefined ? undefined : await context.files.readText(options.blockers);
+  if (options.blockers !== undefined && blockers === undefined) throw new UsageError(`cannot read ${options.blockers}`);
+  const report = await runReview(context, {
+    role: args[0] ?? "",
+    ...(options.item === undefined ? {} : { item: options.item }),
+    ...(round === undefined ? {} : { round }),
+    ...(blockers === undefined ? {} : { blockers }),
+    ...(options.base === undefined ? {} : { base: options.base }),
+  });
+  return { json: report, human: report.report };
+}

package/dist/adapters/inbound/cli/commands/status.js

@@ -0,0 +1,45 @@
+import { checkBuildGate, findOverlaps, showStatus, suggestNext } from "../../../../app/use_cases/project_status.js";
+                                                                               
+import { UsageError,                                                   } from "../cli_context.js";
+
+export async function runStatus(context            , _args          , options         )                         {
+  if (options.gate !== undefined) {
+    if (options.gate !== "build") throw new UsageError(`unknown gate "${options.gate}"; the only gate is build`);
+    const report = await checkBuildGate(context, options.override);
+    const human = report.passed
+      ? report.overridden ? `Build gate overridden and journaled:\n  ${report.reasons.join("\n  ")}` : "Build gate passed."
+      : `Build gate blocked:\n  ${report.reasons.join("\n  ")}`;
+    return { json: report, human, failed: !report.passed };
+  }
+  if (options.overlap) {
+    const report = await findOverlaps(context, options.change);
+    const human = report.overlaps.length === 0
+      ? `No other branch touches what ${report.change} touches.`
+      : report.overlaps.map((o) => `${o.branch}: ${o.item} also touches ${o.shared.join(", ")}`).join("\n");
+    return { json: report, human };
+  }
+  const report = await showStatus(context);
+  const lines = [`Branch: ${report.branch ?? "(none)"}${report.active === undefined ? "" : `, building ${report.active}`}`];
+  for (const doc of report.documents) lines.push(describe(doc.artifact, doc));
+  for (const feature of report.features) {
+    lines.push(describe(`feature ${feature.ref}`, feature.approval));
+    for (const change of feature.changes) {
+      const name = change.ref.split("/")[1] ?? change.ref;
+      lines.push(change.landed !== undefined ? `  ${name}: landed ${change.landed}` : `  ${describe(name, change.approval)}, tasks ${change.tasksDone}/${change.tasksTotal}`);
+    }
+  }
+  for (const change of report.standalone) lines.push(`${describe(`change ${change.ref}`, change.approval)}, tasks ${change.tasksDone}/${change.tasksTotal}`);
+  return { json: report, human: lines.join("\n") };
+}
+
+function describe(label        , status                )         {
+  const detail = status.changed.length > 0 ? ` (${status.changed.join(", ")})` : status.unjournaled === true ? " (no journal entry)" : "";
+  return `${label}: ${status.state}${detail}`;
+}
+
+export async function runNext(context            )                         {
+  const report = await suggestNext(context);
+  const describe = (s                                                   )         => `${s.step}${s.target === undefined ? "" : ` ${s.target}`}: ${s.reason}`;
+  const lines = [`Next: ${describe(report.next)}`, ...report.also.map((s) => `Also: ${describe(s)}`)];
+  return { json: report, human: lines.join("\n") };
+}

package/dist/adapters/inbound/cli/commands.js

@@ -0,0 +1,36 @@
+                                                
+import { runCheck, runLand, runTrace } from "./commands/code.js";
+import { runApprove, runNew, runValidate } from "./commands/documents.js";
+import { runInit } from "./commands/init.js";
+import { runInstall } from "./commands/install.js";
+import { runFeedback, runJournal } from "./commands/journal.js";
+import { runAbandon, runFeatures, runRoadmap, runTask } from "./commands/progress.js";
+import { runReviewCommand } from "./commands/review.js";
+import { runNext, runStatus } from "./commands/status.js";
+
+export const COMMANDS                                                      = {
+  init: { handler: runInit, usage: "init [--name <name>] [--yes] [--agent <agent>] [--package <npm spec>]   set up this repository and install the skills" },
+  install: { handler: runInstall, usage: "install [--agent <agent>]                         install or update the Cruze skills" },
+  validate: { handler: runValidate, usage: "validate                                          check every document against the formats" },
+  status: { handler: runStatus, usage: "status [--gate build [--override <reason>]] [--overlap [--change <ref>]]" },
+  next: { handler: runNext, usage: "next                                              the step to run next on this branch, and why" },
+  approve: { handler: runApprove, usage: "approve <vision|architecture|roadmap|ref|path> [--replan <ID>...] [--rebase <ID>...]   record your approval of a document" },
+  new: { handler: runNew, usage: "new <vision|glossary|architecture|roadmap> | new <feature|change|adr|note> <slug> --title <title> [--feature <ref>] [--roadmap <slug>]" },
+  task: { handler: runTask, usage: "task <done|deviation|reopen> <T#> [text] [--change <ref>] [--commit <sha>]" },
+  features: { handler: runFeatures, usage: "features <add|drop> <slug> [--summary <text> --goals <ids>] [--reason <text>]" },
+  roadmap: { handler: runRoadmap, usage: "roadmap prune                                     clear landed items from the roadmap status when a release closes" },
+  journal: { handler: runJournal, usage: "journal <add <event> --set key=value... [--item <ref>]|list [--event <event>]>" },
+  review: { handler: runReviewCommand, usage: "review <role> [--item <ref>] [--round 1|2 --blockers <file>] [--base <commit>]   run a role in a fresh agent context" },
+  feedback: { handler: runFeedback, usage: "feedback export [--out <file>] [--no-redact]" },
+  trace: { handler: runTrace, usage: "trace [--all] [--change <ref>]                    link scenarios to the tests that prove them" },
+  check: { handler: runCheck, usage: "check [<file>...] [--ci]                          enforce layer rules and file budgets" },
+  abandon: { handler: runAbandon, usage: "abandon <ref> --reason <text>                     archive a feature or standalone change that stops for good" },
+  land: { handler: runLand, usage: "land [<ref>] [--override <reason>]                merge a verified change into the living docs" },
+};
+
+export const USAGE = `Usage: cruze <command> [options]
+
+Commands:
+${Object.values(COMMANDS).map((c) => `  ${c.usage}`).join("\n")}
+
+Every command prints JSON on stdout when it isn't a terminal, or with --json.`;

package/dist/adapters/inbound/cli/parse_command.js

@@ -0,0 +1,90 @@
+import { parseArgs } from "node:util";
+import { UsageError,              } from "./cli_context.js";
+
+                                
+                                                                                      
+                  
+                   
+                
+                   
+ 
+
+export function parseCommand(argv          )                {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        name: { type: "string" },
+        yes: { type: "boolean", short: "y", default: false },
+        agent: { type: "string", multiple: true, default: [] },
+        json: { type: "boolean", default: false },
+        version: { type: "boolean", short: "v", default: false },
+        help: { type: "boolean", short: "h", default: false },
+        title: { type: "string" },
+        feature: { type: "string" },
+        roadmap: { type: "string" },
+        change: { type: "string" },
+        commit: { type: "string" },
+        summary: { type: "string" },
+        goals: { type: "string" },
+        reason: { type: "string" },
+        set: { type: "string", multiple: true, default: [] },
+        item: { type: "string" },
+        event: { type: "string" },
+        out: { type: "string" },
+        "no-redact": { type: "boolean", default: false },
+        all: { type: "boolean", default: false },
+        file: { type: "string", multiple: true, default: [] },
+        ci: { type: "boolean", default: false },
+        gate: { type: "string" },
+        override: { type: "string" },
+        overlap: { type: "boolean", default: false },
+        round: { type: "string" },
+        package: { type: "string" },
+        replan: { type: "string", multiple: true, default: [] },
+        rebase: { type: "string", multiple: true, default: [] },
+        base: { type: "string" },
+        blockers: { type: "string" },
+      },
+    });
+  } catch (error) {
+    throw new UsageError(error instanceof Error ? error.message : String(error));
+  }
+  const { values, positionals } = parsed;
+  const optional =                   (key   , value                    )                             =>
+    value === undefined ? {} : ({ [key]: value }                     );
+  const options          = {
+    yes: values.yes,
+    agent: values.agent,
+    json: values.json,
+    set: values.set,
+    redact: !values["no-redact"],
+    all: values.all,
+    file: values.file,
+    ci: values.ci,
+    overlap: values.overlap,
+    replan: values.replan,
+    rebase: values.rebase,
+    ...optional("name", values.name),
+    ...optional("title", values.title),
+    ...optional("feature", values.feature),
+    ...optional("roadmap", values.roadmap),
+    ...optional("change", values.change),
+    ...optional("commit", values.commit),
+    ...optional("summary", values.summary),
+    ...optional("goals", values.goals),
+    ...optional("reason", values.reason),
+    ...optional("item", values.item),
+    ...optional("event", values.event),
+    ...optional("out", values.out),
+    ...optional("gate", values.gate),
+    ...optional("override", values.override),
+    ...optional("round", values.round),
+    ...optional("package", values.package),
+    ...optional("base", values.base),
+    ...optional("blockers", values.blockers),
+  };
+  return { words: positionals, options, help: values.help, version: values.version };
+}

package/dist/adapters/inbound/cli/run_cli.js

@@ -0,0 +1,50 @@
+import { CruzeError } from "../../../domain/cruze_error.js";
+import {                  UsageError } from "./cli_context.js";
+import { COMMANDS, USAGE } from "./commands.js";
+import { parseCommand } from "./parse_command.js";
+
+                           
+                             
+                             
+                                                                                        
+                            
+ 
+
+/**
+ * Runs one CLI invocation and returns the exit code: 0 on success, 1 when a check fails or
+ * an expected error occurs, 2 for usage errors. Agents get JSON on stdout; people get a summary on stderr.
+ */
+export async function runCli(argv          , context            , terminal          )                  {
+  let json = !terminal.stdoutIsTerminal || argv.includes("--json");
+  try {
+    const parsed = parseCommand(argv);
+    json ||= parsed.options.json;
+    if (parsed.version) {
+      terminal.stdout(context.bundle.version);
+      return 0;
+    }
+    const [name, ...args] = parsed.words;
+    if (parsed.help || name === undefined || name === "help") {
+      terminal.stderr(USAGE);
+      return 0;
+    }
+    const command = COMMANDS[name];
+    if (command === undefined) throw new UsageError(`Unknown command: ${name}`);
+    const result = await command.handler(context, args, parsed.options);
+    terminal.stderr(result.human);
+    if (json) terminal.stdout(JSON.stringify(result.json, null, 2));
+    return result.failed === true ? 1 : 0;
+  } catch (error) {
+    if (error instanceof UsageError) {
+      terminal.stderr(`${error.message}\n\n${USAGE}`);
+      if (json) terminal.stdout(JSON.stringify({ error: { code: "usage", message: error.message } }));
+      return 2;
+    }
+    if (error instanceof CruzeError) {
+      terminal.stderr(`cruze: ${error.message}`);
+      if (json) terminal.stdout(JSON.stringify({ error: { code: error.code, message: error.message } }));
+      return 1;
+    }
+    throw error;
+  }
+}

package/dist/adapters/outbound/git_repository.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+                                                                
+
+const run = promisify(execFile);
+
+/** The git repository at a directory, driven through the git command. */
+export class GitRepository                       {
+                   root        ;
+
+  constructor(root        ) {
+    this.root = root;
+  }
+
+  async currentBranch()                         {
+    const branch = await this.git("rev-parse", "--abbrev-ref", "HEAD");
+    return branch === null || branch === "HEAD" ? null : branch;
+  }
+
+  async headCommit()                         {
+    return this.git("rev-parse", "--short", "HEAD");
+  }
+
+  async userName()                         {
+    const name = await this.git("config", "user.name");
+    const email = await this.git("config", "user.email");
+    if (name === null) return email;
+    return email === null ? name : `${name} <${email}>`;
+  }
+
+  async otherBranches()                    {
+    const current = await this.currentBranch();
+    const listing = await this.git("for-each-ref", "--format=%(refname:short)", "refs/heads", "refs/remotes");
+    return (listing ?? "")
+      .split("\n")
+      .filter((ref) => ref !== "" && ref !== current && !ref.endsWith("/HEAD") && ref !== `origin/${current}`);
+  }
+
+  async filesOnBranch(branch        , dir        )                               {
+    const files = new Map                ();
+    const listing = await this.git("ls-tree", "-r", "--name-only", branch, "--", dir);
+    for (const path of (listing ?? "").split("\n").filter((p) => p !== "")) {
+      const text = await this.git("show", `${branch}:${path}`);
+      if (text !== null) files.set(path, text);
+    }
+    return files;
+  }
+
+          async git(...args          )                         {
+    try {
+      const { stdout } = await run("git", args, { cwd: this.root, maxBuffer: 64 * 1024 * 1024 });
+      return stdout.trimEnd();
+    } catch {
+      return null;
+    }
+  }
+}

package/dist/adapters/outbound/node_project_files.js

@@ -0,0 +1,101 @@
+import { appendFile, lstat, mkdir, readFile, readdir, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+                                                                     
+
+/** Project files on the local disk, confined to one root directory. */
+export class NodeProjectFiles                         {
+                   root        ;
+
+  constructor(root        ) {
+    this.root = resolve(root);
+  }
+
+  async exists(path        )                   {
+    try {
+      await lstat(this.resolve(path));
+      return true;
+    } catch (error) {
+      if (isNotFound(error)) return false;
+      throw error;
+    }
+  }
+
+  async readText(path        )                              {
+    try {
+      return await readFile(this.resolve(path), "utf8");
+    } catch (error) {
+      if (isNotFound(error)) return undefined;
+      throw error;
+    }
+  }
+
+  async writeText(path        , text        )                {
+    const target = this.resolve(path);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, text, "utf8");
+  }
+
+  async appendText(path        , text        )                {
+    const target = this.resolve(path);
+    await mkdir(dirname(target), { recursive: true });
+    await appendFile(target, text, "utf8");
+  }
+
+  async listFiles(path        )                    {
+    try {
+      const entries = await readdir(this.resolve(path), { withFileTypes: true, recursive: true });
+      return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => relative(this.root, join(entry.parentPath, entry.name)).split(sep).join("/"))
+        .sort();
+    } catch (error) {
+      if (isNotFound(error)) return [];
+      throw error;
+    }
+  }
+
+  async move(from        , to        )                {
+    const target = this.resolve(to);
+    await mkdir(dirname(target), { recursive: true });
+    await rename(this.resolve(from), target);
+  }
+
+  async listEntries(path        )                    {
+    try {
+      return (await readdir(this.resolve(path))).sort();
+    } catch (error) {
+      if (isNotFound(error)) return [];
+      throw error;
+    }
+  }
+
+  async remove(path        )                {
+    await rm(this.resolve(path), { recursive: true, force: true });
+  }
+
+  async link(path        , target        )                {
+    const linkPath = this.resolve(path);
+    this.assertInsideRoot(resolve(dirname(linkPath), target));
+    await mkdir(dirname(linkPath), { recursive: true });
+    await rm(linkPath, { recursive: true, force: true });
+    await symlink(target, linkPath, "dir");
+  }
+
+  /** Resolves a project-relative path, refusing anything outside the root. */
+          resolve(path        )         {
+    const absolute = resolve(this.root, path);
+    this.assertInsideRoot(absolute);
+    return absolute;
+  }
+
+          assertInsideRoot(absolute        )       {
+    const fromRoot = relative(this.root, absolute);
+    if (fromRoot.startsWith("..") || isAbsolute(fromRoot)) {
+      throw new Error(`Path escapes the project root: ${absolute}`);
+    }
+  }
+}
+
+function isNotFound(error         )          {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/adapters/outbound/package_bundle.js

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+                                                                                   
+
+/** The skills and templates shipped in the installed Cruze package. */
+export class PackageBundle                   {
+           version        ;
+                   root        ;
+
+          constructor(root        , version        ) {
+    this.root = root;
+    this.version = version;
+  }
+
+  /** Finds the package root by walking up from this module to the nearest package.json. */
+  static async locate(fromUrl         = import.meta.url)                         {
+    let dir = dirname(fileURLToPath(fromUrl));
+    while (!existsSync(join(dir, "package.json"))) {
+      const parent = dirname(dir);
+      if (parent === dir) throw new Error("Cannot find the Cruze package root");
+      dir = parent;
+    }
+    const manifest = JSON.parse(await readFile(join(dir, "package.json"), "utf8"))                       ;
+    return new PackageBundle(dir, manifest.version);
+  }
+
+  async skills()                          {
+    const skillsDir = join(this.root, "skills");
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const folders = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    return Promise.all(
+      folders.map(async (folder) => ({ folder, files: await readTree(join(skillsDir, folder)) })),
+    );
+  }
+
+  async template(path        )                  {
+    return readFile(join(this.root, "templates", path), "utf8");
+  }
+
+  async formatTemplate(name        )                  {
+    return readFile(join(this.root, "skills", "formats", "templates", name), "utf8");
+  }
+}
+
+async function readTree(dir        )                         {
+  const entries = await readdir(dir, { withFileTypes: true, recursive: true });
+  const files = entries.filter((entry) => entry.isFile()).map((entry) => join(entry.parentPath, entry.name));
+  return Promise.all(
+    files.sort().map(async (file) => ({
+      path: relative(dir, file).split(sep).join("/"),
+      text: await readFile(file, "utf8"),
+    })),
+  );
+}

package/dist/adapters/outbound/process_agent_runner.js

@@ -0,0 +1,26 @@
+import { spawn } from "node:child_process";
+                                                                             
+
+/** Runs an agent's non-interactive mode, such as `claude -p`, as a child process. */
+export class ProcessAgentRunner                        {
+                   cwd        ;
+
+  constructor(cwd        ) {
+    this.cwd = cwd;
+  }
+
+  run(command          , prompt        )                    {
+    const [program, ...args] = command;
+    if (program === undefined) return Promise.resolve({ exitCode: 127, output: "", error: "no command configured" });
+    return new Promise((resolve) => {
+      const child = spawn(program, args, { cwd: this.cwd, stdio: ["pipe", "pipe", "pipe"] });
+      let output = "";
+      let error = "";
+      child.stdout.on("data", (chunk        ) => (output += chunk.toString("utf8")));
+      child.stderr.on("data", (chunk        ) => (error += chunk.toString("utf8")));
+      child.on("error", (failure) => resolve({ exitCode: 127, output, error: `${error}${failure.message}` }));
+      child.on("close", (code) => resolve({ exitCode: code ?? 1, output, error }));
+      child.stdin.end(prompt);
+    });
+  }
+}

package/dist/adapters/outbound/system_clock.js

@@ -0,0 +1,14 @@
+                                                      
+
+/** The machine's clock, with dates in its local time zone. */
+export class SystemClock                  {
+  now()       {
+    return new Date();
+  }
+
+  today()         {
+    const date = new Date();
+    const pad = (n        )         => String(n).padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+  }
+}

package/dist/adapters/outbound/terminal_prompter.js

@@ -0,0 +1,22 @@
+import { createInterface } from "node:readline/promises";
+                                                            
+
+/** Asks on the terminal. Questions go to stderr so stdout stays machine-readable. */
+export class TerminalPrompter                     {
+  async ask(question        , fallback        )                  {
+    const terminal = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+      const answer = await terminal.question(`${question} (${fallback}): `);
+      return answer.trim() === "" ? fallback : answer.trim();
+    } finally {
+      terminal.close();
+    }
+  }
+}
+
+/** Used when nobody can answer: without a terminal, or with --yes. */
+export class DefaultAnswerPrompter                     {
+  async ask(_question        , fallback        )                  {
+    return fallback;
+  }
+}

package/dist/app/ports/agent_runner.js

@@ -0,0 +1,11 @@
+/** Starts a coding agent in a fresh context, non-interactively, and collects what it reports. */
+                              
+                                                                            
+                                                            
+ 
+
+                           
+                   
+                 
+                
+ 

package/dist/app/ports/bundle.js

@@ -0,0 +1,22 @@
+/** The assets shipped inside the Cruze package: skills and templates. */
+
+                              
+                                                                  
+               
+               
+ 
+
+                               
+                                                               
+                 
+                       
+ 
+
+                         
+                           
+                                    
+                                                                        
+                                          
+                                                                                
+                                                
+ 

package/dist/app/ports/clock.js

@@ -0,0 +1,6 @@
+/** The current time, so use cases stay deterministic under test. */
+                        
+              
+                                                                                          
+                  
+ 

package/dist/app/ports/project_files.js

@@ -0,0 +1,20 @@
+/** The files of the project Cruze is working in. Paths are relative to the project root. */
+                               
+                                         
+                                                           
+                                                      
+                                                              
+                                                       
+                                                                             
+                                                        
+                                                                                       
+                                               
+                                                                                                           
+                                             
+                                                                                  
+                                                
+                                                                                  
+                                      
+                                                                                                         
+                                                    
+ 

package/dist/app/ports/prompter.js

@@ -0,0 +1,5 @@
+/** Asks the person running Cruze a question. */
+                           
+                                                                                           
+                                                           
+