@nseng-ai/ns 0.1.0 → 0.1.1

package/kernel/pi-text-generation.js

@@ -0,0 +1,120 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+
+// ../../infra/foundation/src/primitives/primitives.ts
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../../kernel/src/runtime/pi-text-generation.ts
+var DEFAULT_MAX_TOKENS = 512;
+var DEFAULT_REASONING = "low";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var PiTextGenerator = class {
+  modelRegistry;
+  completeSimple;
+  loadDefaultModelRegistry;
+  constructor(options = {}) {
+    this.modelRegistry = options.modelRegistry;
+    this.completeSimple = options.completeSimple;
+    this.loadDefaultModelRegistry = options.loadDefaultModelRegistry ?? loadDefaultModelRegistry;
+  }
+  async generateText(request) {
+    const parsed = parsePiModelRef(request.modelRef);
+    if (!parsed.ok) {
+      return { ok: false, error: parsed.error };
+    }
+    const modelRegistry = this.modelRegistry ?? await this.loadDefaultModelRegistry();
+    const model = modelRegistry.find(parsed.provider, parsed.modelId);
+    if (model === void 0) {
+      return { ok: false, error: `Could not find Pi model ${request.modelRef}.` };
+    }
+    const auth = await modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok) {
+      return { ok: false, error: `Pi auth failed for ${request.modelRef}: ${auth.error}` };
+    }
+    if (!auth.apiKey) {
+      return {
+        ok: false,
+        error: `No Pi auth found for ${parsed.provider}. Run /login or configure Pi auth.`
+      };
+    }
+    try {
+      const completeSimple = this.completeSimple ?? await loadCompleteSimple();
+      const response = await completeSimple(
+        model,
+        {
+          systemPrompt: request.system,
+          messages: [
+            {
+              role: "user",
+              content: [{ type: "text", text: request.prompt }],
+              timestamp: Date.now()
+            }
+          ]
+        },
+        {
+          ...auth.headers === void 0 ? {} : { headers: auth.headers },
+          apiKey: auth.apiKey,
+          maxTokens: request.maxTokens ?? DEFAULT_MAX_TOKENS,
+          reasoning: request.reasoning ?? DEFAULT_REASONING,
+          timeoutMs: DEFAULT_TIMEOUT_MS
+        }
+      );
+      if (response.stopReason === "error" || response.stopReason === "aborted") {
+        return {
+          ok: false,
+          error: `Pi model ${request.modelRef} failed to generate text: ${response.errorMessage ?? response.stopReason}`
+        };
+      }
+      const text = response.content.filter(
+        (content) => content.type === "text" && typeof content.text === "string"
+      ).map((content) => content.text).join("\n");
+      if (text.trim().length === 0) {
+        return { ok: false, error: `Pi model ${request.modelRef} returned empty text.` };
+      }
+      const usage = textGenerationUsageFromResponse(response.usage);
+      return {
+        ok: true,
+        text,
+        ...usage === void 0 ? {} : { usage }
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Pi model ${request.modelRef} failed to generate text: ${formatErrorMessage(error)}`
+      };
+    }
+  }
+};
+function textGenerationUsageFromResponse(usage) {
+  if (!Number.isFinite(usage.input) || !Number.isFinite(usage.output)) return void 0;
+  return {
+    inputTokens: usage.input,
+    outputTokens: usage.output
+  };
+}
+function parsePiModelRef(modelRef) {
+  const separator = modelRef.indexOf("/");
+  if (separator <= 0 || separator === modelRef.length - 1) {
+    return {
+      ok: false,
+      error: `Invalid Pi model reference ${JSON.stringify(modelRef)}. Expected provider/model-id.`
+    };
+  }
+  return {
+    ok: true,
+    provider: modelRef.slice(0, separator),
+    modelId: modelRef.slice(separator + 1)
+  };
+}
+async function loadCompleteSimple() {
+  const piAi = await import("@earendil-works/pi-ai");
+  return piAi.completeSimple;
+}
+async function loadDefaultModelRegistry() {
+  const { AuthStorage, ModelRegistry } = await import("@earendil-works/pi-coding-agent");
+  return ModelRegistry.create(AuthStorage.create());
+}
+export {
+  PiTextGenerator
+};

package/kernel/sdk.js

@@ -0,0 +1,157 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+
+// ../../kernel/src/sdk/command.ts
+function defineExtension(extension) {
+  return extension;
+}
+
+// ../../kernel/src/sdk/repo-local-ns-extension.ts
+function repoLocalNsCommandDescriptor(options) {
+  const manifestName = options.manifestName ?? options.command.name;
+  return {
+    command: options.command,
+    ...options.manifestName === void 0 ? {} : { manifestName },
+    ...options.manifestPath === void 0 ? {} : { manifestPath: options.manifestPath },
+    manifestEntry: `./src/commands/${manifestName}.ts`,
+    packageExport: `${options.packageExportPrefix}/${manifestName}`
+  };
+}
+function defineRepoLocalNsExtensionDescriptor(descriptor) {
+  return descriptor;
+}
+
+// ../../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()
+});
+
+// ../../infra/foundation/src/terminal/text-normalization.ts
+function normalizeTextOutput(output) {
+  return stripOuterCodeFence(trimOuterBlankLines(output.replace(/\r\n?/g, "\n")));
+}
+function trimOuterBlankLines(text) {
+  const lines = text.split("\n");
+  let start = 0;
+  let end = lines.length;
+  while (start < end && lines[start]?.trim() === "") {
+    start += 1;
+  }
+  while (end > start && lines[end - 1]?.trim() === "") {
+    end -= 1;
+  }
+  return lines.slice(start, end).join("\n");
+}
+function stripOuterCodeFence(text) {
+  const trimmed = trimOuterBlankLines(text);
+  const lines = trimmed.split("\n");
+  const firstLine = lines[0]?.trim() ?? "";
+  const lastLine = lines[lines.length - 1]?.trim() ?? "";
+  if (lines.length >= 2 && /^```[a-zA-Z0-9_-]*$/.test(firstLine) && lastLine === "```") {
+    return trimOuterBlankLines(lines.slice(1, -1).join("\n"));
+  }
+  return trimmed;
+}
+
+// ../../infra/foundation/src/terminal/text-truncation.ts
+function truncateTextHeadTail(input) {
+  if (input.value.length <= input.maxChars) return input.value;
+  const marker = input.buildMarker(input.markerOmittedChars ?? input.value.length - input.maxChars);
+  const remainingChars = Math.max(0, input.maxChars - marker.length);
+  const headChars = splitHeadChars(remainingChars, input.headRatio, input.headRounding ?? "floor");
+  const tailChars = remainingChars - headChars;
+  const head = maybeTrimEnd(input.value.slice(0, headChars), input.shouldTrimHead === true);
+  const tail = maybeTrimStart(
+    tailChars === 0 ? "" : input.value.slice(input.value.length - tailChars),
+    input.shouldTrimTail === true
+  );
+  return `${head}${marker}${tail}`;
+}
+function truncateTextHead(input) {
+  const value = input.shouldTrimInput === true ? input.value.trim() : input.value;
+  if (value.length <= input.maxChars) return value;
+  let markerState = headMarkerState(input, 0);
+  markerState = refineHeadMarkerState(input, value.length, markerState);
+  markerState = refineHeadMarkerState(input, value.length, markerState);
+  const head = maybeTrimEnd(
+    value.slice(0, markerState.preservedChars),
+    input.shouldTrimHead !== false
+  );
+  return `${head}${markerState.marker}`;
+}
+function headMarkerState(input, omittedChars) {
+  const marker = input.buildMarker(omittedChars);
+  return { marker, preservedChars: Math.max(0, input.maxChars - marker.length) };
+}
+function refineHeadMarkerState(input, valueLength, state) {
+  return headMarkerState(input, valueLength - state.preservedChars);
+}
+function splitHeadChars(remainingChars, headRatio, headRounding) {
+  const rawHeadChars = remainingChars * headRatio;
+  const roundedHeadChars = headRounding === "ceil" ? Math.ceil(rawHeadChars) : Math.floor(rawHeadChars);
+  return Math.max(0, Math.min(remainingChars, roundedHeadChars));
+}
+function maybeTrimEnd(value, shouldTrim) {
+  return shouldTrim ? value.trimEnd() : value;
+}
+function maybeTrimStart(value, shouldTrim) {
+  return shouldTrim ? value.trimStart() : value;
+}
+
+// ../../kernel/src/sdk/result.ts
+function ok(message) {
+  return { ok: true, message };
+}
+function failed(message, exitCode = 1) {
+  return { ok: false, exitCode, message };
+}
+
+// ../../kernel/src/sdk/services.ts
+var noopNsCommandIo = {
+  phase: () => {
+  },
+  notify: () => {
+  },
+  message: () => {
+  },
+  clearPhase: () => {
+  }
+};
+var noopNsProgress = {
+  phase: () => {
+  }
+};
+export {
+  defineExtension,
+  defineRepoLocalNsExtensionDescriptor,
+  failed,
+  noopNsCommandIo,
+  noopNsProgress,
+  normalizeTextOutput,
+  nsExtensionManifestCommandSchema,
+  nsExtensionManifestSchema,
+  nsExtensionPackageManifestSchema,
+  ok,
+  repoLocalNsCommandDescriptor,
+  stripOuterCodeFence,
+  trimOuterBlankLines,
+  truncateTextHead,
+  truncateTextHeadTail,
+  z
+};

package/package.json

@@ -1,15 +1,26 @@
 {
 	"name": "@nseng-ai/ns",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"description": "Checkout-free ns CLI package.",
 	"type": "module",
 	"bin": {
 		"ns": "bin/ns.js"
 	},
+	"exports": {
+		"./kernel/cli": "./kernel/cli.js",
+		"./kernel/command-io": "./kernel/command-io.js",
+		"./kernel/context": "./kernel/context.js",
+		"./kernel/pi-text-generation": "./kernel/pi-text-generation.js",
+		"./kernel/sdk": "./kernel/sdk.js"
+	},
 	"files": [
 		"bin",
+		"kernel",
 		"README.md"
 	],
+	"publishConfig": {
+		"access": "public"
+	},
 	"engines": {
 		"node": ">=24.12.0"
 	},