@sous-io/sous 0.2.15 → 0.2.17

package/src/commands/namespace/show.ts

@@ -4,23 +4,28 @@
  * Shows one namespace in full: the repository publishing it, what that
  * repository says it is for, how much of it this project subscribes to, and
  * every recipe in it with its latest version, its pinned version and its own
- * subscription state. It reads only the indexes sous already has on disk.
+ * subscription state. It reads only the indexes sous already has on disk,
+ * unless `--latest` asks it to read upstream (which saves nothing); `--installed`
+ * narrows the recipes to the ones the lockfile pins.
  */
 
 import { Args } from "@oclif/core";
 import { BaseCommand } from "../../base-command.js";
 import { subscriptionServiceFor } from "../../lib/repos/subscription-service.js";
-import { catalogContextFor } from "../../lib/repos/catalog-inputs.js";
-import { describeNamespace } from "../../lib/repos/catalog.js";
+import { loadCatalogContext } from "../../lib/repos/catalog-inputs.js";
+import { describeInstalled, describeNamespace } from "../../lib/repos/catalog.js";
 import {
   INDENT,
-  RECIPE_COLUMNS,
   describeCoverage,
+  describeIndexSource,
   factIf,
+  printBrowsingNotes,
   printFacts,
+  recipeColumns,
   recipeRows,
 } from "../../lib/repos/catalog-display.js";
 import { renderTable } from "../../utils/table.js";
+import { browsingFlags } from "../../utils/flags.js";
 import {
   blankLine,
   footer,
@@ -53,15 +58,17 @@ export default class NamespaceShow extends BaseCommand {
     }),
   };
 
-  static flags = { ...BaseCommand.baseFlags };
+  static flags = { ...BaseCommand.baseFlags, ...browsingFlags() };
 
   async run(): Promise<void> {
-    const { args } = await this.parse(NamespaceShow);
+    const { args, flags } = await this.parse(NamespaceShow);
 
     showCommandVars({
       Project: this.projectLabel,
       Config: this.configContext.configPath,
       Namespace: args.ref,
+      Reading: describeIndexSource(flags.latest),
+      ...(flags.installed ? { Showing: "only what this project has installed" } : {}),
     });
 
     const service = subscriptionServiceFor({
@@ -70,13 +77,16 @@ export default class NamespaceShow extends BaseCommand {
       shellEnv: this.shellEnv,
     });
 
-    const { inputs } = catalogContextFor({
+    const { inputs, notChecked } = await loadCatalogContext({
       service,
       sousDir: this.configContext.sousDir,
       settings: this.settings,
+      latest: flags.latest,
     });
 
-    const detail = describeNamespace(inputs, args.ref);
+    const detail = flags.installed
+      ? describeInstalled(inputs, args.ref, describeNamespace, "namespace")
+      : describeNamespace(inputs, args.ref);
 
     heading(`The namespace ${detail.namespace}`);
     blankLine();
@@ -85,7 +95,10 @@ export default class NamespaceShow extends BaseCommand {
       { label: "Repository", lines: [detail.repo] },
       ...factIf("Location", detail.repoUrl),
       ...factIf("About", detail.description),
-      { label: "Recipes", lines: [String(detail.recipes.length)] },
+      {
+        label: flags.installed ? "Installed recipes" : "Recipes",
+        lines: [String(detail.recipes.length)],
+      },
       { label: "Subscribed", lines: [describeCoverage(detail.subscribed)] },
     ]);
 
@@ -99,12 +112,19 @@ export default class NamespaceShow extends BaseCommand {
       return;
     }
 
-    for (const line of renderTable(RECIPE_COLUMNS, recipeRows(detail.recipes), {
-      indent: INDENT,
-    })) {
+    for (const line of renderTable(
+      recipeColumns({ installed: flags.installed }),
+      recipeRows(detail.recipes),
+      { indent: INDENT }
+    )) {
       log(indent(line, INDENT));
     }
 
+    printBrowsingNotes({
+      notChecked: notChecked.filter((name) => name === detail.repo),
+      anyLinked: detail.recipes.some((entry) => entry.linkedPath !== undefined),
+    });
+
     footer();
   }
 }

package/src/commands/recipe/list.ts

@@ -3,21 +3,26 @@
  *
  * Shows every recipe the repositories this project trusts publish, with the
  * latest published version, the version this project pins, and whether it is
- * subscribed. It reads only the indexes sous already has on disk, so it works
- * offline; a repository whose index has never been fetched is named at the end
- * rather than being silently left out.
+ * subscribed. By default it reads only the indexes sous already has on disk, so
+ * it works offline; a repository whose index has never been fetched is named at
+ * the end rather than being silently left out. `--latest` reads the indexes
+ * from upstream instead, without saving them, and `--installed` narrows the
+ * listing to what the lockfile pins.
  */
 
 import { BaseCommand } from "../../base-command.js";
 import { subscriptionServiceFor } from "../../lib/repos/subscription-service.js";
-import { catalogContextFor } from "../../lib/repos/catalog-inputs.js";
-import { listRecipes } from "../../lib/repos/catalog.js";
+import { loadCatalogContext } from "../../lib/repos/catalog-inputs.js";
+import { listRecipes, narrowToInstalled } from "../../lib/repos/catalog.js";
 import {
   INDENT,
-  RECIPE_COLUMNS,
+  describeIndexSource,
+  printBrowsingNotes,
+  recipeColumns,
   recipeRows,
 } from "../../lib/repos/catalog-display.js";
 import { renderTable } from "../../utils/table.js";
+import { browsingFlags } from "../../utils/flags.js";
 import {
   blankLine,
   footer,
@@ -37,19 +42,28 @@ export default class RecipeList extends BaseCommand {
    */
   static aliases = ["recipes:list"];
 
-  static examples = ["<%= config.bin %> recipe list"];
+  static examples = [
+    "<%= config.bin %> recipe list",
+    "<%= config.bin %> recipe list --installed --latest",
+  ];
 
-  static flags = { ...BaseCommand.baseFlags };
+  static flags = { ...BaseCommand.baseFlags, ...browsingFlags() };
 
   async run(): Promise<void> {
-    await this.parse(RecipeList);
+    const { flags } = await this.parse(RecipeList);
 
     showCommandVars({
       Project: this.projectLabel,
       Config: this.configContext.configPath,
+      Reading: describeIndexSource(flags.latest),
+      ...(flags.installed ? { Showing: "only what this project has installed" } : {}),
     });
 
-    heading("Recipes in the repositories this project trusts");
+    heading(
+      flags.installed
+        ? "Recipes this project has installed"
+        : "Recipes in the repositories this project trusts"
+    );
 
     const service = subscriptionServiceFor({
       configContext: this.configContext,
@@ -57,13 +71,14 @@ export default class RecipeList extends BaseCommand {
       shellEnv: this.shellEnv,
     });
 
-    const { inputs, notFetched } = catalogContextFor({
+    const { inputs, notFetched, notChecked } = await loadCatalogContext({
       service,
       sousDir: this.configContext.sousDir,
       settings: this.settings,
+      latest: flags.latest,
     });
 
-    const listings = listRecipes(inputs);
+    const listings = listRecipes(flags.installed ? narrowToInstalled(inputs) : inputs);
 
     blankLine();
 
@@ -72,23 +87,25 @@ export default class RecipeList extends BaseCommand {
         inputs.repos.length === 0
           ? "Sous has read no repository index for this project, so there are no " +
             "recipes to show."
-          : "The repositories this project trusts publish no recipes."
+          : flags.installed
+            ? "This project has installed no recipe from the repositories it trusts."
+            : "The repositories this project trusts publish no recipes."
       );
     } else {
-      for (const line of renderTable(RECIPE_COLUMNS, recipeRows(listings), {
-        indent: INDENT,
-      })) {
+      for (const line of renderTable(
+        recipeColumns({ installed: flags.installed }),
+        recipeRows(listings),
+        { indent: INDENT }
+      )) {
         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 is listed: ${notFetched.join(", ")}.`
-      );
-    }
+    printBrowsingNotes({
+      notFetched,
+      notChecked,
+      anyLinked: listings.some((entry) => entry.linkedPath !== undefined),
+    });
 
     footer();
   }

package/src/commands/recipe/show.ts

@@ -6,14 +6,17 @@
  * and where its files land in this project. It reads only what sous already has
  * on disk: the repository's cached index, the project's lockfile, and the
  * recipe's own files when they are in the store or a linked working copy.
+ * `--latest` reads the repository's index from upstream instead, saving
+ * nothing, and `--installed` looks the ref up among installed recipes only.
  */
 
 import { Args } from "@oclif/core";
 import { BaseCommand } from "../../base-command.js";
 import { resolveRootScope } from "../../lib/settings.js";
 import { subscriptionServiceFor } from "../../lib/repos/subscription-service.js";
-import { catalogContextFor } from "../../lib/repos/catalog-inputs.js";
+import { loadCatalogContext } from "../../lib/repos/catalog-inputs.js";
 import {
+  describeInstalled,
   describeRecipe,
   type RecipeContentListing,
   type RecipeDependencyListing,
@@ -22,11 +25,14 @@ import {
 } from "../../lib/repos/catalog.js";
 import {
   INDENT,
+  describeIndexSource,
   describeVersionStatus,
   factIf,
+  printBrowsingNotes,
   printFacts,
 } from "../../lib/repos/catalog-display.js";
 import { renderTable, type TableColumn } from "../../utils/table.js";
+import { browsingFlags } from "../../utils/flags.js";
 import {
   blankLine,
   footer,
@@ -102,15 +108,17 @@ export default class RecipeShow extends BaseCommand {
     }),
   };
 
-  static flags = { ...BaseCommand.baseFlags };
+  static flags = { ...BaseCommand.baseFlags, ...browsingFlags() };
 
   async run(): Promise<void> {
-    const { args } = await this.parse(RecipeShow);
+    const { args, flags } = await this.parse(RecipeShow);
 
     showCommandVars({
       Project: this.projectLabel,
       Config: this.configContext.configPath,
       Recipe: args.ref,
+      Reading: describeIndexSource(flags.latest),
+      ...(flags.installed ? { Showing: "only what this project has installed" } : {}),
     });
 
     const service = subscriptionServiceFor({
@@ -119,14 +127,17 @@ export default class RecipeShow extends BaseCommand {
       shellEnv: this.shellEnv,
     });
 
-    const { inputs } = catalogContextFor({
+    const { inputs, notChecked } = await loadCatalogContext({
       service,
       sousDir: this.configContext.sousDir,
       settings: this.settings,
       scope: resolveRootScope(this.settings, this.configContext),
+      latest: flags.latest,
     });
 
-    const detail = describeRecipe(inputs, args.ref);
+    const detail = flags.installed
+      ? describeInstalled(inputs, args.ref, describeRecipe, "recipe")
+      : describeRecipe(inputs, args.ref);
 
     heading(detail.key);
     blankLine();
@@ -137,11 +148,22 @@ export default class RecipeShow extends BaseCommand {
       ...factIf("About", detail.description),
       { label: "Folder", lines: [detail.path] },
       { label: "Latest version", lines: [detail.latest ?? "none published"] },
-      { label: "Pinned version", lines: [detail.pinned ?? "this project pins none"] },
+      {
+        label: flags.installed ? "Installed version" : "Pinned version",
+        lines: [detail.pinned ?? "this project pins none"],
+      },
+      ...factIf(
+        "Linked",
+        detail.linkedPath === undefined
+          ? undefined
+          : `builds currently read this recipe from the checkout at ${detail.linkedPath}`
+      ),
       { label: "Subscribed", lines: [detail.subscribed ? "yes" : "no"] },
       ...factIf("Described below", detail.describing),
     ]);
 
+    printBrowsingNotes({ notChecked: notChecked.filter((name) => name === detail.repo) });
+
     this.printVersions(detail.versions);
     this.printDependencies(detail.dependencies, detail.manifestRead);
 

package/src/commands/repo/list.ts

@@ -3,9 +3,12 @@
  *
  * Shows every repository this project trusts, what it publishes, and whether it
  * is currently being read from a working copy instead of a published version.
- * It reads only what sous already has on disk: a repository whose index has
- * never been fetched says so in its own row rather than triggering a download,
- * so the command is safe to run offline.
+ * By default it reads only what sous already has on disk: a repository whose
+ * index has never been fetched says so in its own row rather than triggering a
+ * download, so the command is safe to run offline. `--latest` reads each index
+ * from upstream instead, saving nothing, and `--installed` narrows the listing
+ * to the repositories the lockfile pins a recipe from, naming each one under
+ * its row.
  */
 
 import { Flags } from "@oclif/core";
@@ -15,14 +18,24 @@ import { subscriptionServiceFor } from "../../lib/repos/subscription-service.js"
 import { readEffectiveLinks } from "../../lib/repos/links.js";
 import { BUILT_IN_ADDED_BY } from "../../lib/repos/defaults.js";
 import { requireProvider } from "../../lib/repos/providers/index.js";
+import { readTrustedIndexes } from "../../lib/repos/catalog-inputs.js";
+import {
+  LINKED_REPO_NOTE,
+  describeIndexSource,
+  printBrowsingNotes,
+} from "../../lib/repos/catalog-display.js";
 import { renderTable, type TableColumn } from "../../utils/table.js";
+import { browsingFlags } from "../../utils/flags.js";
 import {
   footer,
   indent,
   log,
+  note,
   paragraph,
   section,
   showCommandVars,
+  wrapColumns,
+  wrapText,
 } from "../../utils/formatting.js";
 
 /** How far every line of this command's output is indented. */
@@ -71,10 +84,12 @@ export default class RepoList extends BaseCommand {
   static examples = [
     "<%= config.bin %> repo list",
     "<%= config.bin %> repo list --verbose",
+    "<%= config.bin %> repo list --installed --latest",
   ];
 
   static flags = {
     ...BaseCommand.baseFlags,
+    ...browsingFlags(),
     verbose: Flags.boolean({
       description: "Show the namespaces each repository publishes, under its row",
       default: false,
@@ -87,9 +102,15 @@ export default class RepoList extends BaseCommand {
     showCommandVars({
       Project: this.projectLabel,
       Config: this.configContext.configPath,
+      Reading: describeIndexSource(flags.latest),
+      ...(flags.installed ? { Showing: "only what this project has installed" } : {}),
     });
 
-    section("Repositories this project trusts");
+    section(
+      flags.installed
+        ? "Repositories this project has installed recipes from"
+        : "Repositories this project trusts"
+    );
 
     const service = subscriptionServiceFor({
       configContext: this.configContext,
@@ -98,7 +119,20 @@ export default class RepoList extends BaseCommand {
     });
 
     const repos = service.currentRepos();
-    const names = Object.keys(repos).sort();
+    const lock = service.lockService.read();
+    const names = Object.keys(repos)
+      .sort()
+      .filter(
+        (name) =>
+          !flags.installed ||
+          Object.values(lock.recipes).some((locked) => locked.repo === name)
+      );
+
+    if (names.length === 0 && flags.installed && Object.keys(repos).length > 0) {
+      paragraph("This project has installed no recipe from the repositories it trusts.");
+      footer();
+      return;
+    }
 
     if (names.length === 0) {
       paragraph(
@@ -110,10 +144,12 @@ export default class RepoList extends BaseCommand {
     }
 
     const links = readEffectiveLinks(this.configContext.sousDir);
+    const indexes = await readTrustedIndexes(service, { latest: flags.latest });
+    const indexFor = new Map(indexes.repos.map((entry) => [entry.name, entry.index]));
 
     const rows = names.map((name) => {
       const entry = repos[name]!;
-      const index = service.cachedIndex(name);
+      const index = indexFor.get(name);
       const namespaces =
         index === undefined ? "not fetched" : Object.keys(index.namespaces).sort().join(", ");
       // A repository whose index has never been fetched says so in the cell
@@ -130,19 +166,40 @@ export default class RepoList extends BaseCommand {
         namespaces: namespaces.length > 0 ? namespaces : "none",
         recipes,
         linked: links[name] === undefined ? "no" : `yes: ${links[name]!.path}`,
+        installed: Object.entries(lock.recipes)
+          .filter(([, locked]) => locked.repo === name)
+          .map(([key, locked]) => `${key} ${locked.version}`)
+          .sort()
+          .join(", "),
       };
     });
 
     for (const line of renderTable(COLUMNS, rows, {
       indent: INDENT,
-      rowNote: flags.verbose
-        ? (row) => color.gray(indent(`Namespaces: ${row.namespaces}`, INDENT))
-        : undefined,
+      rowNote: (row) => {
+        const notes: string[] = [];
+        if (flags.verbose) notes.push(`Namespaces: ${row.namespaces}`);
+        if (flags.installed) notes.push(`Installed: ${row.installed}`);
+        // Each note wraps under itself, inside the two indents it is printed at.
+        const width = Math.max(20, wrapColumns() - INDENT * 2);
+        return notes.length === 0
+          ? undefined
+          : notes
+              .flatMap((text) => wrapText(text, width))
+              .map((line) => color.gray(indent(line, INDENT)))
+              .join("\n");
+      },
     })) {
       log(indent(line, INDENT));
     }
 
-    // Everything the table can say, the table says; nothing goes under it.
+    // The table says everything about each repository; what sits under it is
+    // only what the rows could not: a repository upstream could not answer for,
+    // and what a linked row means for the installed recipes it names.
+    printBrowsingNotes({ notChecked: indexes.notChecked.filter((name) => names.includes(name)) });
+    if (flags.installed && names.some((name) => links[name] !== undefined)) {
+      note(LINKED_REPO_NOTE);
+    }
     footer();
   }
 }

package/src/commands/repo/release.ts

@@ -11,6 +11,7 @@ import {
   anythingToCommit,
   buildIndex,
   buildReleasePlan,
+  checkSubmissions,
   bumpRecipeVersion,
   commitPaths,
   createAnnotatedTag,
@@ -391,6 +392,46 @@ export default class RepoRelease extends Command {
       log("  records for every version it publishes.");
     }
     reportPending(result, "These versions have no tag yet; they publish when this merges:");
+
+    // A pull request can be opened without `sous repo submit`, so this check is
+    // the one gate every change passes. The release itself is not restricted:
+    // whatever publishes such a recipe still releases it.
+    section("Checking the recipes that take no proposals");
+    const submissions = await checkSubmissions(validation);
+    if (submissions.refusing.length > 0) {
+      const problems: ValidationProblem[] = submissions.refusing.map((recipe) => ({
+        level: "error",
+        where: recipe.path,
+        message:
+          `this change touches '${recipe.key}', which does not take proposed changes ` +
+          `(${recipe.declaredBy === "recipe" ? "its own manifest" : "the repository manifest"} ` +
+          `says so). Merging it would break whatever publishes the recipe.` +
+          (recipe.instead === undefined ? "" : ` Instead: ${recipe.instead}`),
+      }));
+      reportProblems(problems);
+      displayErrorBlock(
+        `This change cannot be merged: it touches ` +
+          `${describeCount(problems.length, "recipe")} that ${problems.length === 1 ? "does" : "do"} ` +
+          `not take proposed changes, listed above.\n` +
+          `  Take those edits out of the change, and send them where each recipe asks.`
+      );
+      return this.exit(1);
+    }
+    if (submissions.comparedWith.kind === "branch") {
+      log(
+        `  Compared with the branch '${submissions.comparedWith.branch}': this change touches no ` +
+          `recipe that declines proposals.`
+      );
+    } else if (submissions.comparedWith.kind === "tags") {
+      log("  Compared with each recipe's last release tag: nothing that declines proposals changed.");
+    } else if (submissions.comparedWith.kind === "none declined") {
+      log("  No recipe in this repository declines proposed changes.");
+    } else {
+      note(
+        "This checkout holds neither a copy of the default branch nor a release tag of any " +
+          "recipe that declines proposed changes, so there was nothing to compare with."
+      );
+    }
     footer();
   }