Stub in quarto list command

Author: dragonstyle

src/command/command.ts

@@ -22,6 +22,7 @@ import { buildJsCommand } from "./build-js/cmd.ts";
 import { installCommand } from "./install/cmd.ts";
 import { publishCommand } from "./publish/cmd.ts";
 import { removeCommand } from "./remove/cmd.ts";
+import { listCommand } from "./list/cmd.ts";
 
 // deno-lint-ignore no-explicit-any
 export function commands(): Command<any>[] {
@@ -35,6 +36,7 @@ export function commands(): Command<any>[] {
     runCommand,
     installCommand,
     removeCommand,
+    listCommand,
     publishCommand,
     capabilitiesCommand,
     inspectCommand,

src/command/list/cmd.ts

@@ -0,0 +1,105 @@
+/*
+* cmd.ts
+*
+* Copyright (C) 2021 by RStudio, PBC
+*
+*/
+import { Command } from "cliffy/command/mod.ts";
+import { Table } from "cliffy/table/mod.ts";
+import { initYamlIntelligenceResourcesFromFilesystem } from "../../core/schema/utils.ts";
+import { createTempContext } from "../../core/temp.ts";
+
+import { info } from "log/mod.ts";
+import { outputTools } from "../remove/tools-console.ts";
+import { createExtensionContext } from "../../extension/extension.ts";
+import {
+  Extension,
+  ExtensionContext,
+  extensionIdString,
+} from "../../extension/extension-shared.ts";
+import { projectContext } from "../../project/project-context.ts";
+
+export const listCommand = new Command()
+  .hidden()
+  .name("list")
+  .arguments("<type:string>")
+  .description(
+    "Lists an extension or global dependency.",
+  )
+  .example(
+    "List installed extensions",
+    "quarto list extensions",
+  )
+  .example(
+    "List global tools",
+    "quarto list tools",
+  )
+  .action(
+    async (_options: unknown, type: string) => {
+      await initYamlIntelligenceResourcesFromFilesystem();
+      const temp = createTempContext();
+      const extensionContext = createExtensionContext();
+      try {
+        if (type.toLowerCase() === "extensions") {
+          await outputExtensions(Deno.cwd(), extensionContext);
+        } else if (type.toLowerCase() === "tools") {
+          await outputTools();
+        } else {
+          // This is an unrecognized type option
+          info(
+            `Unrecognized option '${type}' - please choose 'tools' or 'extensions'.`,
+          );
+        }
+      } finally {
+        temp.cleanup();
+      }
+    },
+  );
+
+async function outputExtensions(
+  path: string,
+  extensionContext: ExtensionContext,
+) {
+  // Provide the with with a list
+  const project = await projectContext(path);
+  const extensions = extensionContext.extensions(path, project);
+
+  const extensionEntries: string[][] = [];
+
+  const provides = (extension: Extension) => {
+    const contribs: string[] = [];
+    if (
+      extension.contributes.filters && extension.contributes.filters?.length > 0
+    ) {
+      contribs.push("filter");
+    }
+
+    if (
+      extension.contributes.shortcodes &&
+      extension.contributes.shortcodes?.length > 0
+    ) {
+      contribs.push("shortcodes");
+    }
+
+    if (
+      extension.contributes.format
+    ) {
+      contribs.push("formats");
+    }
+    return contribs.join(", ");
+  };
+
+  extensions.forEach((ext) => {
+    const row = [
+      extensionIdString(ext.id),
+      ext.version?.toString() || "(none)",
+      `[${provides(ext)}]`,
+    ];
+    extensionEntries.push(row);
+  });
+
+  const table = new Table().header(["Id", "Version", "Type"]).body(
+    extensionEntries,
+  ).padding(4);
+  info(table.toString());
+}

src/command/remove/tools-console.ts

@@ -5,15 +5,16 @@
 *
 */
 import { Select } from "cliffy/prompt/mod.ts";
-import { allTools } from "../tools/tools.ts";
+import { Table } from "cliffy/table/mod.ts";
+import { allTools, toolSummary } from "../tools/tools.ts";
 
 import { withSpinner } from "../../core/console.ts";
-import { InstallableTool, RemotePackageInfo } from "../tools/types.ts";
-
-interface AllTools {
-  installed: InstallableTool[];
-  notInstalled: InstallableTool[];
-}
+import {
+  InstallableTool,
+  RemotePackageInfo,
+  ToolSummaryData,
+} from "../tools/types.ts";
+import { info, warning } from "log/mod.ts";
 
 interface ToolInfo {
   tool: InstallableTool;
@@ -22,6 +23,66 @@ interface ToolInfo {
   latest: RemotePackageInfo;
 }
 
+export async function outputTools() {
+  const toolRows: string[][] = [];
+  const statusMsgs: string[] = [];
+
+  await withSpinner({
+    message: "Reading Tool Data",
+  }, async () => {
+    // Reads the status
+    const installStatus = (summary: ToolSummaryData): string => {
+      if (summary.installed) {
+        if (summary.installedVersion) {
+          if (summary.installedVersion === summary.latestRelease.version) {
+            return "Up to date";
+          } else {
+            return "Update available";
+          }
+        } else {
+          return "External Installation";
+        }
+      } else {
+        return "Not installed";
+      }
+    };
+
+    // The column widths for output (in chars)
+    const tools = await loadTools();
+    for (const tool of tools) {
+      const summary = await toolSummary(tool.tool.name);
+      if (summary) {
+        const toolDetails = [
+          tool.tool.name,
+          installStatus(summary),
+          summary.installedVersion || "",
+          summary.latestRelease.version,
+        ];
+        toolRows.push(toolDetails);
+
+        if (summary.configuration.status !== "ok") {
+          statusMsgs.push(
+            `${summary.configuration.message}`,
+          );
+        }
+      }
+    }
+  });
+  // Write the output
+  const table = new Table().header([
+    "Tool",
+    "Status",
+    "Installed",
+    "Latest",
+  ]).body(
+    toolRows,
+  ).padding(4);
+  info(table.toString());
+  statusMsgs.forEach((msg) => {
+    warning(msg);
+  });
+}
+
 export async function loadTools(): Promise<ToolInfo[]> {
   let sorted: ToolInfo[] = [];
   await withSpinner({ message: "Inspecting tools" }, async () => {

src/command/tools/tools/tinytex.ts

@@ -119,7 +119,7 @@ async function verifyConfiguration(): Promise<ToolConfigurationState> {
   } else {
     return {
       status: "warning",
-      message: "TeX Live is not available on the path.",
+      message: "TeX Live not on path.",
     };
   }
 }
@@ -340,9 +340,9 @@ This will instruct TeX Live to create symlinks that it needs in <bin_dir_on_path
     }
     const binPathMessage = envPath
       ? `Setting TeXLive Binpath: ${envPath}`
-      : Deno.build.os !== "windows" ?
-      `Updating Path (inspecting ${paths.length} possible paths)` :
-      "Updating Path";
+      : Deno.build.os !== "windows"
+      ? `Updating Path (inspecting ${paths.length} possible paths)`
+      : "Updating Path";
 
     // Ensure symlinks are all set
     await context.withSpinner(