@sous-io/sous 0.2.36 → 1.0.1

package/src/commands/init.ts

@@ -1,289 +0,0 @@
-/**
- * `sous init` sets a project up for sous.
- *
- * It writes the `.sous/` directory a project needs (a commented primary config,
- * the starter prompt that config compiles, the two answers files and the
- * sous-managed ignore block) and then runs the first build, which is what
- * seeds the `core` recipe and pins it in the lockfile. A project that is
- * already set up is left exactly as it is.
- *
- * This is the one command that runs BEFORE a project config exists, so it
- * opts out of the config requirement every other command inherits. Discovery
- * still runs, which is how `--sous-dir` and `SOUS_DIR` say where to write, and
- * how a run inside an existing project is noticed.
- */
-
-import path from "node:path";
-import { Args, Flags } from "@oclif/core";
-import { confirm } from "@inquirer/prompts";
-import { BaseCommand } from "../base-command.js";
-import { runProjectBuild } from "../lib/build-service.js";
-import {
-  CONFIG_FILE_NAMES,
-  SOUS_DIR_NAME,
-  discoverConfig,
-  expandHome,
-  resolveConfigFlag,
-} from "../lib/config-discovery.js";
-import { ConfigError } from "../lib/errors.js";
-import { nonInteractiveError } from "../lib/interactive.js";
-import {
-  PROJECT_CONFIG_FORMATS,
-  SOUS_PACKAGE_NAME,
-  STARTER_OUTPUT_NAME,
-  STARTER_PROMPT_RELATIVE_PATH,
-  scaffoldProject,
-  sousDirFor,
-  type PackageJsonOutcome,
-  type ProjectConfigFormat,
-} from "../lib/project-scaffold/index.js";
-import { SOUS_VERSION } from "../lib/settings.js";
-import { confirmationFlag } from "../utils/flags.js";
-import {
-  blankLine,
-  dryRunNotice,
-  footer,
-  log,
-  paragraph,
-  section,
-  showCommandVars,
-  showVariables,
-  warning,
-  type VariableEntry,
-} from "../utils/formatting.js";
-
-/**
- * The "Dependency" row of the summary: where sous now sits in the project's
- * package.json, or nothing when the project has no package.json.
- */
-function dependencyRow(outcome: PackageJsonOutcome): VariableEntry[] {
-  if (outcome.kind === "absent") return [];
-  const value = `${SOUS_PACKAGE_NAME} ${outcome.range}`;
-  if (outcome.kind === "present") {
-    return [{ label: "Dependency", value, detail: `already in ${outcome.section} in package.json` }];
-  }
-  return [
-    {
-      label: "Dependency",
-      value,
-      detail: "added to devDependencies in package.json; run your package manager's install to fetch it",
-    },
-  ];
-}
-
-export default class Init extends BaseCommand {
-  static description =
-    "Set a project up for sous: write its .sous/ directory, then run the first build";
-
-  /** This command creates the config; finding none is its normal case. */
-  static override requiresConfig = false;
-
-  static examples = [
-    "<%= config.bin %> init",
-    "<%= config.bin %> init ./my-project",
-    "<%= config.bin %> init --format json",
-    "<%= config.bin %> init --name 'My Project' --no-build",
-    "<%= config.bin %> init --dry-run",
-  ];
-
-  static args = {
-    directory: Args.string({
-      description: "Project directory to set up (defaults to the current one)",
-      required: false,
-    }),
-  };
-
-  static flags = {
-    ...BaseCommand.baseFlags,
-    format: Flags.string({
-      description: "Format of the primary config to write",
-      options: [...PROJECT_CONFIG_FORMATS],
-      default: PROJECT_CONFIG_FORMATS[0],
-    }),
-    name: Flags.string({
-      description: "Display name for the project (defaults to the directory's own name)",
-    }),
-    // The one question this command can ask: whether to set up a project
-    // inside another one.
-    yes: confirmationFlag(),
-    "dry-run": Flags.boolean({
-      description: "Print the files that would be written without writing them",
-      default: false,
-    }),
-    "no-build": Flags.boolean({
-      description: "Write the setup without running the first build",
-      default: false,
-    }),
-  };
-
-  async run(): Promise<void> {
-    const { args, flags } = await this.parse(Init);
-    const dryRun = flags["dry-run"];
-    const format = flags.format as ProjectConfigFormat;
-
-    const sousDir = this.targetSousDir(args.directory);
-    const projectRoot = path.dirname(sousDir);
-
-    showCommandVars({
-      Directory: projectRoot,
-      Config: path.join(sousDir, `sous.config.${format}`),
-      Name: flags.name ?? "(from the directory name)",
-      "Dry Run": dryRun,
-      Build: !dryRun && !flags["no-build"],
-    });
-
-    await this.confirmNesting(projectRoot, flags.yes);
-
-    section("Setting up the project");
-
-    const result = await scaffoldProject({
-      sousDir,
-      format,
-      name: flags.name,
-      dryRun,
-      sousVersion: SOUS_VERSION,
-    });
-
-    for (const file of result.files) {
-      if (result.dryRun) dryRunNotice(`would write ${file}`);
-      else log(`  wrote ${file}`);
-    }
-    if (result.packageJson.kind === "added") {
-      const what = `${SOUS_PACKAGE_NAME} ${result.packageJson.range} to devDependencies in package.json`;
-      if (result.dryRun) dryRunNotice(`would add ${what}`);
-      else log(`  added ${what}`);
-    }
-
-    if (result.dryRun) {
-      blankLine();
-      dryRunNotice("Nothing was written. Run the same command without '--dry-run' to set the project up.");
-      footer();
-      return;
-    }
-
-    if (!flags["no-build"]) {
-      await this.buildProject(result.configPath);
-    }
-
-    section("What was set up");
-    showVariables([
-      { label: "Config", value: result.configPath },
-      { label: "Prompt source", value: path.join(sousDir, STARTER_PROMPT_RELATIVE_PATH) },
-      { label: "Compiled to", value: path.join(projectRoot, STARTER_OUTPUT_NAME) },
-      { label: "Skills", value: path.join(projectRoot, ".claude", "skills") },
-      ...dependencyRow(result.packageJson),
-      { label: "Shared answers", value: path.join(sousDir, ".env"), detail: "committed" },
-      {
-        label: "Local answers",
-        value: path.join(sousDir, ".env.local"),
-        detail: "gitignored; .env.local.example shows the layout",
-      },
-    ]);
-
-    blankLine();
-    paragraph(
-      `  ${STARTER_OUTPUT_NAME} and the skills directory are build output, compiled from the ` +
-        `prompt source and from the recipes this project subscribes to; a build recompiles ` +
-        `them. The config explains each of its blocks in its own comments.`
-    );
-
-    footer();
-  }
-
-  /**
-   * Where the `.sous/` directory goes. A directory argument wins; otherwise the
-   * config-locating flags say where the project is, and otherwise it is the
-   * working directory. A path that already names a `.sous/` directory, or a
-   * config file inside one, is honored as such.
-   */
-  private targetSousDir(directory: string | undefined): string {
-    if (directory !== undefined) {
-      return sousDirFor(path.resolve(this.configLocator.cwd, expandHome(directory)));
-    }
-
-    const primary = this.configLocator.primary;
-    if (primary === undefined) return sousDirFor(this.configLocator.cwd);
-
-    const value = primary.value;
-    if (path.basename(value) === SOUS_DIR_NAME) return value;
-    if ((CONFIG_FILE_NAMES as readonly string[]).includes(path.basename(value))) {
-      return path.dirname(value);
-    }
-    return sousDirFor(value);
-  }
-
-  /**
-   * A project set up inside another one is a real choice, not a mistake sous
-   * should prevent: a subproject may want its own instructions. So when a walk
-   * up from the target finds a config in a parent directory, the facts are
-   * stated and the question is asked once; `--yes` answers it ahead of time,
-   * and a run with no terminal fails naming that flag.
-   *
-   * The target's own `.sous/` holding a config is a different case, refused
-   * outright by the scaffold.
-   */
-  private async confirmNesting(projectRoot: string, confirmed: boolean): Promise<void> {
-    const enclosing = discoverConfig(projectRoot);
-    if (enclosing === null || path.dirname(enclosing.sousDir) === projectRoot) return;
-
-    const enclosingRoot = path.dirname(enclosing.sousDir);
-
-    warning(
-      `${projectRoot} is inside a project that is already set up for sous.\n` +
-        `  The enclosing project's config is ${enclosing.configPath}.\n` +
-        `  Setting this directory up too gives it a config of its own: commands run ` +
-        `here will find this one, and commands run from ${enclosingRoot} will keep ` +
-        `finding the other.`
-    );
-
-    if (confirmed) return;
-
-    if (!this.interactive) {
-      throw nonInteractiveError({
-        prompt: `whether to set up ${projectRoot} inside the project at ${enclosingRoot}`,
-        remedy: "pass --yes (also -y, --force) to set it up anyway",
-      });
-    }
-
-    blankLine();
-    const proceed = await confirm({
-      message: `Set up ${projectRoot} as a project of its own?`,
-      default: false,
-    });
-    if (!proceed) {
-      throw new ConfigError(
-        `Nothing was written. Run 'sous init' from a directory outside ${enclosingRoot}, ` +
-          `or pass --yes to set this one up anyway.`
-      );
-    }
-  }
-
-  /**
-   * Adopts the config just written and builds the project with it, through
-   * the same build `sous build` runs: the repositories are prepared (which
-   * seeds the core recipe into the store and pins it in the lockfile), then
-   * the outputs are compiled.
-   *
-   * @param configPath - The primary config the scaffold wrote.
-   */
-  private async buildProject(configPath: string): Promise<void> {
-    await this.adoptConfig(
-      resolveConfigFlag(configPath, this.configLocator.cwd, this.configLocator.confDirOverride)
-    );
-
-    const succeeded = await runProjectBuild({
-      settings: this.settings,
-      configContext: this.configContext,
-      shellEnv: this.shellEnv,
-      heading: "Building the project",
-    });
-
-    if (!succeeded) {
-      throw new ConfigError(
-        `The project is set up, but the first build failed, so its outputs may be ` +
-          `incomplete. Everything 'sous init' wrote is in place; fix what the build ` +
-          `reported above and run 'sous build' again.`
-      );
-    }
-  }
-}

package/src/commands/launch.ts

@@ -1,139 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import { BaseCommand } from "../base-command.js";
-import { runProjectBuild } from "../lib/build-service.js";
-import { ConfigError } from "../lib/errors.js";
-import { resolveRootScope, resolveTools } from "../lib/settings.js";
-import { displayError, footer, heading, showCommandVars } from "../utils/formatting.js";
-
-export default class Launch extends BaseCommand {
-  static description =
-    "Build this project's outputs, then start a coding agent configured in its config";
-
-  static examples = [
-    "<%= config.bin %> launch claude",
-    "<%= config.bin %> launch codex --no-build",
-    "<%= config.bin %> launch claude --continuous",
-    "<%= config.bin %> launch claude --resume",
-    "<%= config.bin %> launch claude -- -c",
-  ];
-
-  static args = {
-    tool: Args.string({
-      description: "Tool to launch (e.g. claude, codex)",
-      required: true,
-    }),
-  };
-
-  static flags = {
-    ...BaseCommand.baseFlags,
-    "no-build": Flags.boolean({
-      description: "Skip sous build before launching",
-      default: false,
-    }),
-    continuous: Flags.boolean({
-      description: "Restart the agent automatically on exit",
-      default: false,
-    }),
-  };
-
-  // Any argument launch does not recognize is forwarded to the tool, after the
-  // config-defined tool args. Flags that collide with sous's own (e.g. claude's
-  // -c / --continue vs sous's -c / --config) can be forced through with `--`:
-  // everything after it is forwarded verbatim.
-  //
-  // strict=false lets extra positionals through; "--"=false is what routes
-  // unknown flags into argv instead of a NonExistentFlagsError (oclif rejects
-  // them even in non-strict mode otherwise). Disabling oclif's `--` handling
-  // means it would keep parsing sous flags past the separator, so run() splits
-  // argv at the first `--` itself, before oclif ever sees the tail.
-  static strict = false;
-  static "--" = false;
-
-  async run(): Promise<void> {
-    const sepIndex = this.argv.indexOf("--");
-    const ownArgv = sepIndex === -1 ? this.argv : this.argv.slice(0, sepIndex);
-    const verbatimArgs = sepIndex === -1 ? [] : this.argv.slice(sepIndex + 1);
-
-    const { args, argv, flags } = await this.parse(Launch, ownArgv);
-
-    // argv holds every token oclif did not claim, in original order; the first
-    // is the tool name itself.
-    const passThroughArgs = [...argv.slice(1).map(String), ...verbatimArgs];
-
-    const rootScope = resolveRootScope(this.settings, this.configContext);
-    const tools = resolveTools(this.settings, rootScope);
-    const toolConfig = tools[args.tool];
-
-    if (!toolConfig) {
-      displayError(
-        `Tool '${args.tool}' not found in ${this.configContext.configPath}. ` +
-          `Available tools: ${Object.keys(tools).join(", ") || "(none)"}`
-      );
-      this.exit(1);
-    }
-
-    const projectRoot = rootScope.projectRoot ?? process.cwd();
-
-    showCommandVars({
-      Project: this.projectLabel,
-      Config: this.configContext.configPath,
-      Tool: args.tool,
-      "Project Root": projectRoot,
-      "No Build": flags["no-build"],
-      Continuous: flags.continuous,
-      ...(passThroughArgs.length > 0 && { "Tool Args": passThroughArgs.join(" ") }),
-    });
-
-    do {
-      // Build step (unless --no-build). A failed build stops here: the agent
-      // would otherwise start on outputs the build could not bring up to date.
-      if (!flags["no-build"]) {
-        const built = await runProjectBuild({
-          settings: this.settings,
-          configContext: this.configContext,
-          shellEnv: this.shellEnv,
-        });
-        if (!built) {
-          throw new ConfigError(
-            `The build failed, so ${args.tool} was not started. Fix the errors listed ` +
-              `above, or pass --no-build to start it with the outputs as they are.`
-          );
-        }
-      }
-
-      // Config-defined args first, then pass-through, then promptFile content
-      const launchArgs = [...(toolConfig.args ?? []), ...passThroughArgs];
-      if (toolConfig.promptFile) {
-        if (!fs.existsSync(toolConfig.promptFile)) {
-          displayError(`promptFile not found: ${toolConfig.promptFile}`);
-          this.exit(1);
-        }
-        const promptContent = fs.readFileSync(toolConfig.promptFile, "utf8");
-        launchArgs.push(promptContent);
-      }
-
-      heading(`Launching ${args.tool}`);
-
-      // Run the tool with inherited stdio (interactive)
-      const result = spawnSync(toolConfig.command, launchArgs, {
-        cwd: projectRoot,
-        stdio: "inherit",
-        shell: false,
-      });
-
-      if (result.error) {
-        displayError(`Failed to launch '${args.tool}': ${result.error.message}`);
-        this.exit(1);
-      }
-
-      if (flags.continuous) {
-        // Small delay to avoid tight spin on immediate crash
-        await new Promise(resolve => setTimeout(resolve, 150));
-      }
-    } while (flags.continuous);
-
-    footer();
-  }
-}

package/src/commands/lock/rebuild.ts

@@ -1,239 +0,0 @@
-/**
- * `sous lock rebuild`.
- *
- * Recomputes the lockfile from scratch: every subscription this project
- * declares is resolved against the cached repository indexes, the whole
- * dependency closure beneath them is walked, and the result replaces the
- * lockfile outright. An entry nothing holds any more is dropped, which is what
- * makes this the repair for a lockfile that has drifted from the config: a
- * hand-edited file, a bad merge, or a subscription removed from the config by
- * hand rather than with `sous subscription remove`.
- *
- * It is an edge-case utility, so it is deliberately blunt. It never asks a
- * question and never grants trust: a subscription whose repository this project
- * has not added is an error naming the repository. It downloads nothing; a
- * repository whose index has not been fetched is named, and nothing in it can
- * be resolved.
- */
-
-import { Flags } from "@oclif/core";
-import { BaseCommand } from "../../base-command.js";
-import { ConfigError } from "../../lib/errors.js";
-import { subscriptionServiceFor } from "../../lib/repos/subscription-service.js";
-import { recipeFilesDirectory } from "../../lib/repos/catalog-inputs.js";
-import { readRecipeManifestIn } from "../../lib/repos/locked-recipes.js";
-import { createEmptyLockfile } from "../../lib/repos/formats/lockfile.js";
-import type { LockRepoInput } from "../../lib/repos/lock-service.js";
-import { RefSource, parseNamedRef } from "../../services/ref-resolver/index.js";
-import {
-  PROJECT_REQUESTER,
-  resolveRefs,
-  type RefRequest,
-  type ResolverRepo,
-} from "../../lib/repos/resolver.js";
-import type { IndexFile } from "../../lib/repos/formats/index-file.js";
-import {
-  blankLine,
-  dryRunNotice,
-  footer,
-  heading,
-  indent,
-  log,
-  paragraph,
-  showCommandVars,
-} from "../../utils/formatting.js";
-
-/** How far every line of this command's output is indented. */
-const INDENT = 2;
-
-export default class LockRebuild extends BaseCommand {
-  static description =
-    "Rebuild this project's lockfile from its subscriptions and the cached repository indexes";
-
-  /**
-   * The other spelling of the topic. It lives under a hidden topic, so it is
-   * typable everywhere without ever reaching the top-level listing.
-   */
-  static aliases = ["locks:rebuild"];
-
-  static examples = [
-    "<%= config.bin %> lock rebuild",
-    "<%= config.bin %> lock rebuild --dry-run",
-  ];
-
-  static flags = {
-    ...BaseCommand.baseFlags,
-    "dry-run": Flags.boolean({
-      description: "Print what would change without writing the lockfile",
-      default: false,
-    }),
-  };
-
-  async run(): Promise<void> {
-    const { flags } = await this.parse(LockRebuild);
-    const dryRun = flags["dry-run"];
-
-    showCommandVars({
-      Project: this.projectLabel,
-      Config: this.configContext.configPath,
-      "Dry Run": dryRun,
-    });
-
-    heading("Rebuilding the lockfile");
-
-    const service = subscriptionServiceFor({
-      configContext: this.configContext,
-      settings: this.settings,
-      shellEnv: this.shellEnv,
-    });
-
-    const sousDir = this.configContext.sousDir;
-    const trusted = service.currentRepos();
-
-    const repos: Record<string, ResolverRepo> = {};
-    const lockRepos: Record<string, LockRepoInput> = {};
-    const indexes = new Map<string, IndexFile>();
-    const notFetched: string[] = [];
-
-    const before = service.lockService.read();
-
-    for (const name of Object.keys(trusted).sort()) {
-      const entry = trusted[name]!;
-      const identity = service.identityForRepo(name);
-      if (identity === undefined) continue;
-
-      repos[name] = {
-        url: entry.url,
-        identity,
-        ...(entry.provider === undefined ? {} : { provider: entry.provider }),
-        ...(entry.alwaysPull === undefined ? {} : { alwaysPull: entry.alwaysPull }),
-      };
-      lockRepos[name] = {
-        url: entry.url,
-        identity,
-        ...(entry.provider === undefined ? {} : { provider: entry.provider }),
-        // The index a resolution was made against is recorded per repository.
-        // A rebuild resolves against the same cached index the last one did, so
-        // whatever the lockfile already recorded still holds.
-        ...(before.repos[name]?.indexHash === undefined
-          ? {}
-          : { indexHash: before.repos[name]!.indexHash! }),
-      };
-
-      const index = service.cachedIndex(name);
-      if (index === undefined) {
-        notFetched.push(name);
-        continue;
-      }
-      indexes.set(name, index);
-    }
-
-    const subscriptions = service.allSubscriptions();
-    const requests: RefRequest[] = Object.keys(subscriptions)
-      .sort()
-      .map((key) => {
-        const entry = subscriptions[key]!;
-        return {
-          ref: parseNamedRef(key, RefSource.Config),
-          ...(entry.range === undefined ? {} : { range: entry.range }),
-          requestedBy: PROJECT_REQUESTER,
-          kind: "subscribes" as const,
-          ...(entry.prerelease === true ? { prerelease: true } : {}),
-        };
-      });
-
-    const result = await resolveRefs(requests, {
-      indexes,
-      repos,
-      // A recipe's own manifest is what names its dependencies, and it is read
-      // from the files this machine already holds. Nothing is fetched here, so a
-      // recipe that is not in the store yet is walked from what its index entry
-      // records, and comes back under `missingManifests` when that is nothing.
-      loadManifest: (recipe) => {
-        const directory = recipeFilesDirectory({
-          service,
-          sousDir,
-          repo: recipe.repo,
-          key: recipe.key,
-          namespace: recipe.namespace,
-          name: recipe.name,
-          version: recipe.version,
-        });
-        return directory === undefined ? undefined : readRecipeManifestIn(directory);
-      },
-    });
-
-    if (result.missingRepos.length > 0) {
-      throw new ConfigError(
-        `This project's subscriptions need ${
-          result.missingRepos.length === 1 ? "a repository" : "repositories"
-        } it does not trust, so the lockfile cannot be rebuilt:\n` +
-          result.missingRepos
-            .map(
-              (missing) =>
-                `  ${missing.name}${missing.url === undefined ? "" : ` (${missing.url})`}, ` +
-                `needed by ${missing.requiredBy.map((entry) => entry.ref).join(", ")}`
-            )
-            .join("\n") +
-          `\n  Add ${
-            result.missingRepos.length === 1 ? "it" : "them"
-          } with 'sous repo add <url>', which is how a repository is trusted, then run ` +
-          `this command again.`
-      );
-    }
-
-    // The rebuild starts from an empty lockfile rather than the one on disk, so
-    // an entry nothing in the resolution holds any more is gone rather than
-    // carried through.
-    const after = service.lockService.applyResolution(
-      createEmptyLockfile(),
-      result.resolved,
-      lockRepos
-    );
-    const diff = service.lockService.diff(before, after);
-
-    blankLine();
-    for (const line of diff.lines) log(indent(line, INDENT));
-
-    if (notFetched.length > 0) {
-      blankLine();
-      paragraph(
-        `These repositories are trusted and their index has not been fetched yet, so ` +
-          `nothing in them could be resolved: ${notFetched.join(", ")}.`
-      );
-    }
-
-    if (result.missingManifests.length > 0) {
-      blankLine();
-      paragraph(
-        `The files of these recipes are not on this machine, and their repository's ` +
-          `index does not record what they depend on, so their own dependencies are ` +
-          `not in the rebuilt lockfile: ${result.missingManifests.join(", ")}.`
-      );
-    }
-
-    for (const cycle of result.cycles) {
-      blankLine();
-      paragraph(`These recipes depend on each other in a circle: ${cycle.join(" -> ")}.`);
-    }
-
-    blankLine();
-
-    if (dryRun) {
-      dryRunNotice(`Nothing was written. The lockfile is ${service.lockService.filePath}.`);
-      footer();
-      return;
-    }
-
-    const written = service.lockService.write(after);
-    paragraph(
-      `The lockfile was rebuilt from ${requests.length} ${
-        requests.length === 1 ? "subscription" : "subscriptions"
-      } and now pins ${Object.keys(after.recipes).length} ${
-        Object.keys(after.recipes).length === 1 ? "recipe" : "recipes"
-      }: ${written}.`
-    );
-
-    footer();
-  }
-}