@nseng-ai/ns 0.1.0 → 0.1.1

package/kernel/command-io.js

@@ -0,0 +1,139 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+
+// ../../infra/foundation/src/primitives/primitives.ts
+function optionalEntries(entries) {
+  return Object.fromEntries(
+    Object.entries(entries).filter(([, value]) => value !== void 0)
+  );
+}
+function optionalEntry(key, value) {
+  return optionalEntries({ [key]: value });
+}
+
+// ../../kernel/src/sdk/schema.ts
+import { z } from "zod";
+
+// ../../kernel/src/sdk/extension-manifest.ts
+var nsExtensionManifestCommandSchema = z.looseObject({
+  name: z.string().optional(),
+  path: z.array(z.string()).optional(),
+  group: z.string().optional(),
+  description: z.string().optional(),
+  fullDescription: z.string().optional(),
+  entry: z.string().optional()
+});
+var nsExtensionManifestSchema = z.looseObject({
+  description: z.string().optional(),
+  group: z.string().optional(),
+  commands: z.array(z.unknown()).optional()
+});
+var nsExtensionPackageManifestSchema = z.looseObject({
+  description: z.string().optional(),
+  ns: nsExtensionManifestSchema.optional()
+});
+
+// ../../kernel/src/sdk/services.ts
+var noopNsCommandIo = {
+  phase: () => {
+  },
+  notify: () => {
+  },
+  message: () => {
+  },
+  clearPhase: () => {
+  }
+};
+var noopNsProgress = {
+  phase: () => {
+  }
+};
+
+// ../../kernel/src/runtime/command-io.ts
+async function runWithNsCommandIo(io, fn) {
+  try {
+    return await fn(io);
+  } finally {
+    io.clearPhase();
+  }
+}
+function createCliCommandIo(input, options = {}) {
+  const onOutput = input.onOutput;
+  const io = createCommandIo({
+    ...optionalEntries({
+      phaseTransient: onOutput === void 0 ? void 0 : (text) => onOutput("stderr", text),
+      phaseFallback: input.stderr,
+      notifyInfo: input.stdout,
+      notifyDiagnostic: input.stderr,
+      shouldSuppress: options.shouldSuppress
+    })
+  });
+  const onNotifyError = options.onNotifyError;
+  if (onNotifyError === void 0) return io;
+  return {
+    ...io,
+    notify: (message, level = "info") => {
+      if (level === "error") onNotifyError();
+      io.notify(message, level);
+    }
+  };
+}
+function createCommandIo(channels) {
+  function phase(message2) {
+    if (channels.shouldSuppress === true) return;
+    if (channels.phaseSticky !== void 0) {
+      channels.phaseSticky(message2);
+      return;
+    }
+    const line = `${message2}
+`;
+    if (channels.phaseTransient !== void 0) {
+      channels.phaseTransient(line);
+      return;
+    }
+    channels.phaseFallback?.(line);
+  }
+  function notify(message2, level = "info") {
+    if (channels.notifyUi !== void 0) {
+      channels.notifyUi(message2, level);
+      return;
+    }
+    const line = `${message2.trimEnd()}
+`;
+    if (level === "info" && channels.shouldSuppress !== true) {
+      channels.notifyInfo?.(line);
+      return;
+    }
+    channels.notifyDiagnostic?.(line);
+  }
+  function message(text, options = {}) {
+    const level = options.level ?? "info";
+    if (channels.richMessage !== void 0) {
+      channels.richMessage(text, {
+        level,
+        ...optionalEntry("details", options.details)
+      });
+      return;
+    }
+    if (options.isRichOnly === true) return;
+    phase(text);
+  }
+  function clearPhase() {
+    channels.phaseSticky?.(void 0);
+  }
+  return { phase, notify, message, clearPhase };
+}
+function commandIoFromNsExtensionApi(ctx, options = {}) {
+  if (options.shouldSuppress === void 0) return ctx.commandIo;
+  return createCliCommandIo(
+    optionalEntries({ stdout: ctx.stdout, stderr: ctx.stderr, onOutput: ctx.onOutput }),
+    { shouldSuppress: options.shouldSuppress }
+  );
+}
+export {
+  commandIoFromNsExtensionApi,
+  createCliCommandIo,
+  createCommandIo,
+  noopNsCommandIo,
+  noopNsProgress,
+  runWithNsCommandIo
+};