@tdk-landscape/tdk-cli-core 1.3.45 → 1.3.49

package/cli/src/commands/resources.ts

@@ -0,0 +1,95 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { createDiscoveryContext } from "../utils/discovery-context.js";
+import { requireProjectRoot, runCommand } from "../utils/errors.js";
+import {
+  formatCount,
+  showAllSatisfyCondition,
+  showDetail,
+  showEmptyState,
+  showStep,
+} from "../utils/formatting.js";
+
+export const resourcesCommand = new Command("resources")
+  .description("List all resources (services) in the project")
+  .option("-v, --verbose", "Show detailed information about each resource", false)
+  .option("-s, --stack <stack>", "Filter resources by stack name")
+  .option("--no-stack", "Show only resources without a stack")
+  .option("--ports", "Show port assignments", false)
+  .action(async (options) => {
+    await runCommand(async () => {
+      requireProjectRoot();
+
+      const discovery = createDiscoveryContext();
+
+      if (discovery.resources.length === 0) {
+        showEmptyState("resources");
+        return;
+      }
+
+      let resources = discovery.resources;
+
+      if (options.stack) {
+        resources = discovery.resourcesByStack.get(options.stack) || [];
+        if (resources.length === 0) {
+          showEmptyState("stack-services", ` in stack "${options.stack}"`);
+          return;
+        }
+      }
+
+      if (options.noStack) {
+        resources = discovery.unassignedResources;
+        if (resources.length === 0) {
+          showAllSatisfyCondition("resources", "assigned to a stack");
+          return;
+        }
+      }
+
+      showStep(`Found ${formatCount(resources.length, "resource")}:\n`);
+
+      if (options.verbose || options.ports) {
+        for (const resource of resources) {
+          console.log(chalk.bold(`${resource.name}`));
+
+          if (resource.stack) {
+            console.log(chalk.gray(`  Stack: ${resource.stack}`));
+          } else {
+            console.log(chalk.yellow(`  Stack: (not assigned)`));
+          }
+
+          if (options.ports && resource.port) {
+            console.log(chalk.gray(`  Port: ${resource.port}`));
+          }
+
+          if (options.verbose) {
+            console.log(chalk.gray(`  Type: ${resource.type || "unknown"}`));
+            console.log(chalk.gray(`  Path: ${resource.configPath}`));
+          }
+
+          console.log();
+        }
+      } else {
+        for (const resource of resources) {
+          const stackInfo = resource.stack
+            ? chalk.gray(` [${resource.stack}]`)
+            : chalk.yellow(" [no stack]");
+          console.log(`  ${resource.name}${stackInfo}`);
+        }
+
+        showDetail("\nRun with --verbose for more details or --ports to see port assignments.", 0);
+      }
+
+      const withoutStackCount = options.stack
+        ? resources.filter((r: { stack?: string }) => !r.stack).length
+        : discovery.unassignedResources.length;
+
+      if (withoutStackCount > 0 && !options.noStack && !options.stack) {
+        console.log(
+          chalk.yellow(
+            `\n${formatCount(withoutStackCount, "resource")} not assigned to any stack.`,
+          ),
+        );
+        showDetail('Run "tdk resources --no-stack" to see them, or "tdk stack" to assign them.');
+      }
+    });
+  });

package/cli/src/commands/stack.ts

@@ -0,0 +1,128 @@
+import { readFileSync } from "node:fs";
+import chalk from "chalk";
+import { Command } from "commander";
+import { confirmOrCancel } from "../utils/command-helpers.js";
+import { clearDiscoveryCache, createDiscoveryContext } from "../utils/discovery-context.js";
+import { requireProjectRoot, runCommand } from "../utils/errors.js";
+import { writeJsonFile } from "../utils/file-helpers.js";
+import {
+  formatCount,
+  showAllSatisfyCondition,
+  showCommandHeader,
+  showDetail,
+  showSuccess,
+} from "../utils/formatting.js";
+import { promptMultiSelect, promptText } from "../utils/prompt.js";
+import { createKebabCaseValidator } from "../utils/validation.js";
+
+export const stackCommand = new Command("stack")
+  .description("Organize resources into stacks (groups)")
+  .argument("[stack-name]", "Stack name to assign to resources")
+  .option("--list", "List resources without a stack", false)
+  .action(async (stackName, options) => {
+    await runCommand(async () => {
+      requireProjectRoot();
+
+      showCommandHeader("Stack Management");
+
+      const discovery = createDiscoveryContext();
+
+      if (discovery.resources.length === 0) {
+        console.log(
+          chalk.yellow(
+            "No resources discovered. Make sure you're in a project with service.json files.",
+          ),
+        );
+        return;
+      }
+
+      showDetail(`Found ${formatCount(discovery.resources.length, "resource")}\n`, 0);
+
+      if (discovery.stackNames.length > 0) {
+        console.log(chalk.bold("Existing stacks:"));
+        for (const name of discovery.stackNames) {
+          const count = discovery.resourcesByStack.get(name)?.length || 0;
+          showDetail(`${name} (${formatCount(count, "resource")})`);
+        }
+        console.log();
+      }
+
+      if (options.list) {
+        if (discovery.unassignedResources.length === 0) {
+          showAllSatisfyCondition("resources", "already assigned to a stack");
+          return;
+        }
+
+        console.log(
+          chalk.bold(`${discovery.unassignedResources.length} resources without a stack:`),
+        );
+        for (const resource of discovery.unassignedResources) {
+          showDetail(`${resource.name}`);
+          showDetail(`${resource.configPath}`, 4);
+        }
+        return;
+      }
+
+      let targetStack = stackName;
+      if (!targetStack) {
+        const name = await promptText({
+          message: "Stack name (kebab-case recommended):",
+          validate: (input: string) => {
+            const validation = createKebabCaseValidator("stack")(input);
+            return validation === true || validation;
+          },
+        });
+        targetStack = name;
+      }
+
+      const resourcesToUpdate = discovery.unassignedResources;
+
+      if (resourcesToUpdate.length === 0) {
+        console.log(chalk.yellow("\nNo resources available to add to this stack."));
+        return;
+      }
+
+      const selectedResources = await promptMultiSelect({
+        message: `Select resources to add to stack "${targetStack}":`,
+        choices: resourcesToUpdate.map((r) => ({
+          title: r.name,
+          value: r.configPath,
+        })),
+        validate: (input: string[]) => {
+          if (input.length === 0) return "Select at least one resource";
+          return true;
+        },
+      });
+
+      if (selectedResources.length === 0) {
+        console.log(chalk.yellow("No resources selected. Exiting."));
+        return;
+      }
+
+      showDetail(
+        `\nWill add "stack": "${targetStack}" to ${formatCount(selectedResources.length, "resource")}.`,
+        0,
+      );
+
+      const confirmed = await confirmOrCancel("Proceed?");
+      if (!confirmed) return;
+
+      // Clear cache since we're about to modify resources
+      clearDiscoveryCache();
+
+      let updated = 0;
+      for (const configPath of selectedResources) {
+        const content = readFileSync(configPath, "utf-8");
+        const config = JSON.parse(content);
+        config.stack = targetStack;
+        writeJsonFile(configPath, config);
+
+        updated++;
+        showSuccess(`${config.appName || configPath}`);
+      }
+
+      console.log();
+      showSuccess(`Updated ${formatCount(updated, "resource")}.`);
+      showDetail(`\nYou can now run: tdk up ${targetStack}`, 0);
+    });
+  });

package/cli/src/commands/stacks.ts

@@ -0,0 +1,52 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { createDiscoveryContext } from "../utils/discovery-context.js";
+import { runCommand } from "../utils/errors.js";
+import { formatCount, showDetail, showEmptyState, showStep } from "../utils/formatting.js";
+
+export const stacksCommand = new Command("stacks")
+  .description("List all stacks and their resources")
+  .alias("ls") // Keep 'tdk ls' as shorthand
+  .option("-v, --verbose", "Show detailed information about each stack", false)
+  .option("--services", "Include list of services in each stack", false)
+  .action(async (options) => {
+    await runCommand(async () => {
+      const discovery = createDiscoveryContext();
+
+      if (discovery.stackNames.length === 0) {
+        showEmptyState("stacks");
+        return;
+      }
+
+      if (options.verbose || options.services) {
+        showStep(`Found ${formatCount(discovery.stacks.length, "stack")}:\n`);
+
+        for (const stack of discovery.stacks) {
+          console.log(chalk.bold(`${stack.name}`));
+          showDetail(`${stack.description}`);
+
+          if (options.services) {
+            showDetail("Services:");
+            for (const service of stack.resources) {
+              showDetail(`${service.name}`, 4);
+            }
+          }
+
+          console.log();
+        }
+      } else {
+        showStep(`Found ${formatCount(discovery.stackNames.length, "stack")}:\n`);
+
+        for (const name of discovery.stackNames) {
+          const serviceCount = discovery.resourcesByStack.get(name)?.length || 0;
+          console.log(chalk.bold(`  ${name}`));
+          showDetail(`${formatCount(serviceCount, "service")}`, 4);
+        }
+
+        showDetail(
+          "\nRun with --verbose for more details, or --services to see all services in each stack.",
+          0,
+        );
+      }
+    });
+  });

package/cli/src/commands/status.ts

@@ -0,0 +1,88 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { createDiscoveryContext } from "../utils/discovery-context.js";
+import { runCommand } from "../utils/errors.js";
+import { formatCount, showDetail, showStep } from "../utils/formatting.js";
+import { getTiltfilePath, isTiltAvailable, runTilt } from "../utils/tilt.js";
+
+export const statusCommand = new Command("status")
+  .description("Show status of resources and stacks")
+  .option("-v, --verbose", "Show detailed information", false)
+  .option("--stacks", "Show stack information (default)", true)
+  .option("--resources", "Show all discovered resources", false)
+  .option("--tilt", "Show tilt resource status", false)
+  .action(async (options) => {
+    await runCommand(async () => {
+      let tiltAvailable = false;
+      try {
+        tiltAvailable = await isTiltAvailable();
+      } catch {
+        // Tilt not available (spawn error)
+        tiltAvailable = false;
+      }
+
+      showStep("TDK Status\n");
+      console.log(
+        chalk.bold("Tilt:"),
+        tiltAvailable ? chalk.green("available") : chalk.red("not found"),
+      );
+
+      if (!tiltAvailable) {
+        showDetail("Install Tilt: https://docs.tilt.dev/install.html");
+      }
+
+      console.log();
+
+      const discovery = createDiscoveryContext();
+      console.log(chalk.bold("Resources:"), `${discovery.resources.length} discovered`);
+      console.log(chalk.bold("Stacks:"), `${discovery.stacks.length} defined`);
+
+      if (discovery.stacks.length > 0) {
+        for (const stack of discovery.stacks) {
+          const resourcesInStack = stack.resources.length;
+          showDetail(`${stack.name}: ${formatCount(resourcesInStack, "resource")}`);
+
+          if (options.verbose) {
+            for (const resource of stack.resources) {
+              showDetail(`${resource.name}`, 6);
+            }
+          }
+        }
+      }
+
+      if (discovery.unassignedResources.length > 0) {
+        console.log();
+        console.log(
+          chalk.yellow(
+            `${formatCount(discovery.unassignedResources.length, "resource")} not in any stack:`,
+          ),
+        );
+
+        if (options.verbose) {
+          for (const resource of discovery.unassignedResources) {
+            showDetail(`${resource.name}`);
+          }
+        }
+      }
+
+      if (options.tilt && tiltAvailable) {
+        console.log();
+        showStep("Tilt Resources:");
+
+        const tiltfilePath = getTiltfilePath();
+        const result = await runTilt("get", ["-f", tiltfilePath, "resources"], {
+          inheritStdio: false,
+        });
+
+        if (result.exitCode === 0) {
+          console.log(result.stdout || chalk.gray("  No active tilt resources"));
+        } else {
+          showDetail("Could not retrieve tilt resource status");
+        }
+      }
+
+      console.log();
+      showDetail('Run "tdk list-stacks" to see all stacks.');
+      showDetail('Run "tdk up <stack-name>" to start a stack.');
+    });
+  });