@tyvm/knowhow 0.0.159 → 0.0.161

package/src/index.ts

@@ -1,261 +0,0 @@
-import { summarizeFiles, summarizeFile } from "./ai";
-import type { AgentOptions } from "./ai";
-import * as fs from "fs";
-import * as path from "path";
-import * as crypto from "crypto";
-import { globSync } from "glob";
-
-import { Prompts } from "./prompts";
-import {
-  Config,
-  Hashes,
-  Embeddable,
-  GenerationSource,
-  EmbeddingModels,
-} from "./types";
-import { readFile, writeFile, fileExists } from "./utils";
-import {
-  getConfig,
-  loadPrompt,
-  updateConfig,
-  getIgnorePattern,
-} from "./config";
-import {
-  embedJson,
-  embedKind,
-  getConfiguredEmbeddings,
-  pruneEmbedding,
-  loadEmbedding,
-  saveEmbedding,
-  embedSource,
-  getConfiguredEmbeddingMap,
-} from "./embeddings";
-
-import { convertToText } from "./conversion";
-import { knowhowMcpClient } from "./services/Mcp";
-import { services } from "./services/";
-import { Models } from "./types";
-
-// ---------------------------------------------------------------------------
-// Re-export generate pipeline (moved to src/generate.ts)
-// ---------------------------------------------------------------------------
-export {
-  generate,
-  GenerateOptions,
-  buildWaves,
-  normalizeInputPattern,
-  withOutputTarget,
-  writeAgentOrSummaryOutput,
-  handleMultiOutputGeneration,
-  handleSingleOutputGeneration,
-} from "./generate";
-
-export * as clients from "./clients";
-export type {
-  Tool,
-  ToolProp,
-  ToolCall,
-  Message,
-  CompletionOptions,
-  CompletionResponse,
-} from "./clients/types";
-export * as agents from "./agents";
-export * as services from "./services";
-export * as embeddings from "./embeddings";
-export * as types from "./types";
-export * as processors from "./processors";
-export * as ai from "./ai";
-export * from "./processes/ProcessManager";
-
-// Export module system types for external modules
-export * from "./services/modules/types";
-export { ModulesService } from "./services/modules";
-export * from "./services/modules/computerUse";
-// Export conversion types for external modules (e.g. knowhow-module-pdf)
-export * from "./services/conversion/types";
-export { ConversionService } from "./services/conversion/ConversionService";
-// Export plugin types for external plugins
-export { PluginBase } from "./plugins/PluginBase";
-export { PluginMeta, Plugin, PluginContext } from "./plugins/types";
-export { PluginService } from "./plugins/plugins";
-export { SkillsPlugin } from "./plugins/SkillsPlugin";
-// Export embedding types
-export { MinimalEmbedding, Embeddable } from "./types";
-
-// ---------------------------------------------------------------------------
-// Embed
-// ---------------------------------------------------------------------------
-
-export async function embed() {
-  const config = await getConfig();
-  const ignorePattern = await getIgnorePattern();
-
-  const defaultModel =
-    config.embeddingModel || EmbeddingModels.openai.EmbeddingAda2;
-
-  if (!config.embedSources) {
-    return;
-  }
-
-  for (const source of config.embedSources) {
-    await embedSource(defaultModel, source, ignorePattern);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Purge
-// ---------------------------------------------------------------------------
-
-export async function purge(globPath: string) {
-  const files = globSync(globPath);
-  const embeddings = await getConfiguredEmbeddingMap();
-  const config = await getConfig();
-  const chunkSizes = config.embedSources.reduce((acc, source) => {
-    acc[source.output] = source.chunkSize;
-    return acc;
-  }, {});
-
-  for (const file of Object.keys(embeddings)) {
-    let pruned = embeddings[file];
-    for (const filePath of files) {
-      const before = pruned.length;
-      pruned = pruned
-        .filter((e) => !filePath || !e.id.startsWith("./" + filePath))
-        .filter((e) => e.text.length <= chunkSizes[file]);
-      const after = pruned.length;
-
-      if (after < before) {
-        console.log("Purging", filePath);
-      }
-    }
-    await saveEmbedding(file, pruned);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Upload
-// ---------------------------------------------------------------------------
-
-export async function upload() {
-  const config = await getConfig();
-  const { AwsS3, Embeddings, knowhowApiClient } = services();
-
-  for (const source of config.embedSources) {
-    const bucketName = source.remote;
-
-    if (!source.remoteType) {
-      console.log(
-        "Skipping",
-        source.output,
-        "because no remoteType is configured"
-      );
-      continue;
-    }
-    const items = JSON.parse(await readFile(source.output, "utf8"));
-    const { name: embeddingName } = path.parse(source.output);
-
-    if (Embeddings.hasResolver(source.remoteType) && source.remoteType !== "knowhow") {
-      console.log(
-        "Uploading",
-        source.output,
-        "to",
-        `${bucketName}/${embeddingName}.json`
-      );
-      const remoteKey = `${embeddingName}.json`;
-      await Embeddings.upload(source.remoteType, source.output, bucketName, remoteKey);
-    } else if (source.remoteType === "knowhow") {
-      if (!source.remoteId) {
-        throw new Error("remoteId is required for knowhow uploads");
-      }
-      try {
-        const remoteEmbedding = await knowhowApiClient.getOrgEmbedding(source.remoteId);
-        const localModel = config.embeddingModel || EmbeddingModels.openai.EmbeddingAda2;
-        const remoteModel = remoteEmbedding?.modelName;
-        if (remoteModel && remoteModel !== localModel) {
-          console.warn(
-            `⚠️  WARNING: Embedding model mismatch for "${remoteEmbedding.name}" (remoteId: ${source.remoteId}).\n` +
-            `   Local config.embeddingModel:  ${localModel}\n` +
-            `   Backend embedding modelName:  ${remoteModel}\n` +
-            `   Vectors generated with different models are not comparable — search results will be incorrect.\n` +
-            `   Update your config.embeddingModel to "${remoteModel}" or update the backend embedding to "${localModel}".`
-          );
-        }
-      } catch (e) {
-        // Non-fatal
-      }
-      const url = await knowhowApiClient.getPresignedUploadUrl(source);
-      console.log("Uploading to", url);
-      await AwsS3.uploadToPresignedUrl(url, source.output);
-      await knowhowApiClient.updateEmbeddingMetadata(source.remoteId, {
-        inputGlob: source.input,
-        outputPath: source.output,
-        chunkSize: source.chunkSize,
-        remoteType: source.remoteType,
-      });
-      console.log("Synced metadata for", source.remoteId);
-    } else {
-      console.log(
-        "Skipping upload to",
-        source.remoteType,
-        "for",
-        source.remote
-      );
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Download
-// ---------------------------------------------------------------------------
-
-export async function download() {
-  const config = await getConfig();
-  const { AwsS3, Embeddings, knowhowApiClient } = services();
-
-  for (const source of config.embedSources) {
-    const { remote, remoteType } = source;
-
-    if (!remoteType) {
-      console.log(
-        "Skipping",
-        source.output,
-        "because no remoteType is configured"
-      );
-      continue;
-    }
-
-    const { name } = path.parse(source.output);
-    const fileName = `${name}.json`;
-    const destinationPath = source.output;
-
-    if (Embeddings.hasResolver(remoteType)) {
-      console.log(
-        "Downloading",
-        fileName,
-        `from ${remoteType}`,
-        remote,
-        "to",
-        destinationPath
-      );
-      const embeddingPath = ".knowhow/embeddings/" + fileName;
-      await Embeddings.download(remoteType, remote, embeddingPath, destinationPath);
-    } else if (remoteType === "knowhow") {
-      if (!source.remoteId) {
-        throw new Error("remoteId is required for knowhow downloads");
-      }
-      console.log(
-        "Downloading",
-        fileName,
-        "from Knowhow",
-        "to",
-        destinationPath
-      );
-      const preSignedUrl = await knowhowApiClient.getPresignedDownloadUrl(source);
-      const outputDir = path.dirname(destinationPath);
-      if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
-      await AwsS3.downloadFromPresignedUrl(preSignedUrl, destinationPath);
-    } else {
-      console.log("Unsupported remote type for", source.output);
-    }
-  }
-}

package/src/logger.ts

@@ -1,197 +0,0 @@
-import type { LogLevel } from "./services/EventService";
-
-/**
- * App-wide logger utility.
- *
- * Features:
- * 1. `logger.info/warn/error(source, message)` — routes through EventService
- * 2. `Logger.of("ClassName")` — creates a bound logger so you don't repeat the source
- * 3. `logger.installConsoleOverload()` — replaces console.log/warn/error/info with
- *    our closure, so ALL output (including third-party modules) goes through us
- * 4. `logger.silence()` / `logger.unsilence()` — suppress all output, useful for
- *    commands that need clean stdout (e.g. github-credentials)
- *
- * Usage (module-level):
- *   import { logger } from "../logger";
- *   logger.info("MyService", "Something happened");
- *
- * Usage (class-level):
- *   import { Logger } from "../logger";
- *   class MyClass {
- *     private logger = Logger.of("MyClass");
- *     doThing() { this.logger.info("Something happened"); }
- *   }
- *
- * Silence mode (for clean-stdout commands):
- *   logger.silence();   // suppress everything
- *   // ... do work that must produce clean stdout ...
- *   logger.unsilence(); // restore
- */
-
-// ---- Internal state ---------------------------------------------------------
-
-let silenced = false;
-
-// Original console methods — saved before any overload is installed
-const _originalConsole = {
-  log: console.log.bind(console),
-  warn: console.warn.bind(console),
-  error: console.error.bind(console),
-  info: console.info.bind(console),
-};
-
-let consoleOverloadInstalled = false;
-
-// ---- EventService lazy accessor ---------------------------------------------
-
-function getEvents() {
-  try {
-    const { services } = require("./services") as typeof import("./services");
-    return services().Events;
-  } catch {
-    return null;
-  }
-}
-
-// ---- Core emit logic --------------------------------------------------------
-
-function emit(source: string, message: string, level: LogLevel): void {
-  if (silenced) return;
-
-  try {
-    const events = getEvents();
-    if (events) {
-      events.log(source, message, level);
-      return;
-    }
-  } catch {
-    // fall through to direct console output
-  }
-
-  // Fallback: use original console methods (bypasses any overload we installed)
-  const prefix = source ? `[${source}] ` : "";
-  if (level === "warn") _originalConsole.warn(`${prefix}${message}`);
-  else if (level === "error") _originalConsole.error(`${prefix}${message}`);
-  else _originalConsole.log(`${prefix}${message}`);
-}
-
-// ---- Bound logger (returned by Logger.of) -----------------------------------
-
-export interface BoundLogger {
-  log(message: string, level?: LogLevel): void;
-  info(message: string): void;
-  warn(message: string): void;
-  error(message: string): void;
-}
-
-function makeBoundLogger(source: string): BoundLogger {
-  return {
-    log(message: string, level: LogLevel = "info"): void {
-      emit(source, message, level);
-    },
-    info(message: string): void {
-      emit(source, message, "info");
-    },
-    warn(message: string): void {
-      emit(source, message, "warn");
-    },
-    error(message: string): void {
-      emit(source, message, "error");
-    },
-  };
-}
-
-// ---- Public API -------------------------------------------------------------
-
-export const logger = {
-  log(source: string, message: string, level: LogLevel = "info"): void {
-    emit(source, message, level);
-  },
-
-  info(source: string, message: string): void {
-    emit(source, message, "info");
-  },
-
-  warn(source: string, message: string): void {
-    emit(source, message, "warn");
-  },
-
-  error(source: string, message: string): void {
-    emit(source, message, "error");
-  },
-
-  /**
-   * Suppress all log output. Useful for commands that need clean stdout
-   * (e.g. git credential helpers). All logger.* calls and overloaded
-   * console.* calls become no-ops until unsilence() is called.
-   */
-  silence(): void {
-    silenced = true;
-  },
-
-  /**
-   * Restore log output after a silence() call.
-   */
-  unsilence(): void {
-    silenced = false;
-  },
-
-  /**
-   * Returns true if the logger is currently silenced.
-   */
-  isSilenced(): boolean {
-    return silenced;
-  },
-
-  /**
-   * Install console overload. After this call, console.log/warn/error/info
-   * all route through our closure (respecting silence mode).
-   * Safe to call multiple times — only installs once.
-   *
-   * Call this early in CLI startup (before any modules are loaded) to ensure
-   * third-party module logs don't bypass the silence mechanism.
-   */
-  installConsoleOverload(): void {
-    if (consoleOverloadInstalled) return;
-    consoleOverloadInstalled = true;
-
-    const route = (originalFn: (...args: any[]) => void, args: any[]) => {
-      if (silenced) return;
-      originalFn(...args);
-    };
-
-    console.log = (...args: any[]) => route(_originalConsole.log, args);
-    console.info = (...args: any[]) => route(_originalConsole.info, args);
-    console.warn = (...args: any[]) => route(_originalConsole.warn, args);
-    // Note: console.error is intentionally NOT overloaded — real errors (stack
-    // traces, crash reports) should always be visible. Only suppress via silence().
-    // If you want to suppress errors too, call logger.silence() which checks the flag
-    // before the overloaded console.warn/log routes reach here anyway.
-  },
-
-  /**
-   * Remove the console overload and restore original console methods.
-   */
-  uninstallConsoleOverload(): void {
-    if (!consoleOverloadInstalled) return;
-    console.log = _originalConsole.log;
-    console.info = _originalConsole.info;
-    console.warn = _originalConsole.warn;
-    consoleOverloadInstalled = false;
-  },
-};
-
-/**
- * Factory for creating a bound logger with a fixed source name.
- * Ideal for class-level loggers:
- *
- *   class MyClass {
- *     private logger = Logger.of("MyClass");
- *     doThing() { this.logger.info("hello"); }
- *   }
- */
-export const Logger = {
-  of(source: string): BoundLogger {
-    return makeBoundLogger(source);
-  },
-};

package/src/login.ts

@@ -1,209 +0,0 @@
-import http from "./utils/http";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { ask } from "./utils";
-import { getConfig, updateConfig } from "./config";
-import { KNOWHOW_API_URL } from "./services/KnowhowClient";
-import { BrowserLoginService } from "./auth/browserLogin";
-import { authenticateWithKey, hasKeyPair, registerPublicKey } from "./auth/keyAuth";
-import { getDefaultPrivateKeyPath, getOrCreatePublicKey } from "./auth/keyManager";
-import { storeJwtForApi } from "./auth/jwtStore";
-import { getOrgIdForApi, setOrgIdForApi } from "./auth/environmentAuth";
-import {
-  createRemote,
-  findRemoteForApi,
-  inferRemoteName,
-  registerRemote,
-  resolveJwtPath,
-} from "./remotes";
-import { KnowhowRemote } from "./types";
-
-/**
- * Log in to Knowhow.
- *
- * Strategy (in order):
- *   1. `--jwt`   flag: prompt for a raw JWT and write it to disk.
- *   2. Key auth: if an Ed25519 key and configured organization exist, sign a
- *                server challenge and exchange it for an organization-bound JWT.
- *   3. Browser:  open the browser approval flow (first-time login or key not yet registered).
- *
- * After any successful login the local config is updated with the current user's orgId.
- *
- * @param jwtFlag      True when --jwt flag is passed.
- * @param identityPath Optional path to a specific private key file (--identity flag).
- */
-export async function login(
-  jwtFlag?: boolean,
-  identityPath?: string,
-  apiUrl: string = KNOWHOW_API_URL,
-  remoteName?: string
-): Promise<void> {
-  const config = await getConfig();
-  const remote = findRemoteForApi(config, apiUrl) ??
-    createRemote(remoteName ?? inferRemoteName(apiUrl), apiUrl);
-
-  if (jwtFlag) {
-    const jwt = await ask("Enter your JWT: ");
-    const jwtFile = storeJwtForApi(jwt, remote.apiUrl, remote.jwtPath);
-    console.log(`JWT updated successfully in ${path.relative(process.cwd(), jwtFile)}.`);
-  } else {
-    const selectedIdentityPath = identityPath ?? getDefaultPrivateKeyPath();
-    const orgId = getOrgIdForApi(config, remote.apiUrl);
-
-    if (orgId && hasKeyPair(selectedIdentityPath)) {
-      console.log("Found CLI identity — authenticating with public key...");
-      try {
-        const success = await authenticateWithKey(orgId, remote.apiUrl, selectedIdentityPath);
-        if (success) {
-          console.log("✅ Successfully authenticated via public key!");
-          return await postLoginConfigUpdate(remote, selectedIdentityPath);
-        }
-        console.warn("Key authentication returned no JWT, falling back to browser login...");
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`Key authentication failed (${message}), falling back to browser login...`);
-      }
-    }
-
-    await doBrowserLogin(remote, selectedIdentityPath, orgId);
-    identityPath = selectedIdentityPath;
-  }
-
-  await postLoginConfigUpdate(remote, identityPath);
-}
-
-/** Complete browser PKCE, then best-effort bootstrap the selected identity. */
-async function doBrowserLogin(
-  remote: KnowhowRemote,
-  identityPath?: string,
-  orgId?: string
-): Promise<void> {
-  console.log("Starting browser-based authentication...");
-  try {
-    const browserLoginService = new BrowserLoginService(remote.apiUrl, orgId);
-    await browserLoginService.login();
-    console.log("✅ Successfully authenticated via browser!");
-
-    try {
-      const keyPair = getOrCreatePublicKey(identityPath);
-      await registerPublicKey(
-        await loadJwt(remote),
-        keyPair.publicKeyBase64,
-        remote.apiUrl
-      );
-      console.log(`Registered CLI identity ${keyPair.fingerprint}`);
-    } catch (registrationError: unknown) {
-      // Browser login remains valid when key registration is unavailable (for
-      // example during a rolling backend deployment or for a partial identity).
-      const message = registrationError instanceof Error
-        ? registrationError.message
-        : String(registrationError);
-      console.warn(`Could not register CLI identity (${message}). Browser login is still active.`);
-    }
-  } catch (error: unknown) {
-    const msg = error instanceof Error ? error.message : String(error);
-    console.error("Browser authentication failed:", msg);
-    console.log("You can try manual JWT login with: knowhow login --jwt");
-    throw error;
-  }
-}
-
-function isTemporaryIdentityPath(identityPath: string): boolean {
-  const resolvedIdentity = path.resolve(identityPath);
-  const temporaryRoots = new Set([os.tmpdir(), "/tmp", "/var/tmp"]);
-  return Array.from(temporaryRoots).some((temporaryRoot) => {
-    const relativePath = path.relative(path.resolve(temporaryRoot), resolvedIdentity);
-    return relativePath !== "" && !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
-  });
-}
-
-/** After any successful login, update the local config with the current user/org. */
-async function postLoginConfigUpdate(
-  remote: KnowhowRemote,
-  identityPath?: string
-): Promise<void> {
-  try {
-    const storedJwt = await loadJwt(remote);
-    const { user, currentOrg } = await checkJwt(storedJwt, remote.apiUrl);
-    const orgId = currentOrg?.organizationId;
-
-    console.log(
-      `Current user: ${user.email}, \nOrganization: ${currentOrg?.organization?.name} - ${currentOrg?.organization?.id}`
-    );
-
-    const config = await getConfig();
-
-    if (!config.modelProviders) {
-      config.modelProviders = [];
-    }
-
-    const hasProvider = config.modelProviders.find(
-      (provider: { provider: string }) => provider.provider === "knowhow"
-    );
-    if (!hasProvider) {
-      config.modelProviders.push({ provider: "knowhow" });
-    }
-
-    registerRemote(config, orgId ? { ...remote, orgId } : remote);
-    config.activeRemote = remote.name;
-    if (orgId) {
-      setOrgIdForApi(config, remote.apiUrl, orgId);
-    }
-
-    if (identityPath && !isTemporaryIdentityPath(identityPath)) {
-      config.cliIdentityPath = path.resolve(identityPath);
-    } else if (
-      config.cliIdentityPath && isTemporaryIdentityPath(config.cliIdentityPath)
-    ) {
-      delete config.cliIdentityPath;
-    }
-
-    await updateConfig(config);
-  } catch (error: unknown) {
-    if (http.isHttpError(error) && error.response) {
-      const errData = (error as any).body ?? { message: "Unknown error" };
-      throw new Error(
-        `Error: ${(error as any).status} - ${errData?.message || "Unknown error"}`
-      );
-    }
-    console.log(
-      "Error: Unable to fetch user information. Please check your JWT and try again.",
-      error
-    );
-  }
-}
-
-export async function loadJwt(remote?: KnowhowRemote): Promise<string> {
-  const selectedRemote = remote ??
-    findRemoteForApi(await getConfig(), KNOWHOW_API_URL) ??
-    createRemote(inferRemoteName(KNOWHOW_API_URL), KNOWHOW_API_URL);
-  const jwtFile = resolveJwtPath(selectedRemote.jwtPath);
-  const jwt = fs.existsSync(jwtFile) ? fs.readFileSync(jwtFile, "utf8").trim() : "";
-
-  if (!jwt) {
-    if (!fs.existsSync(jwtFile)) {
-      throw new Error(`Error: JWT file not found: ${jwtFile}`);
-    }
-    throw new Error("Error: JWT is empty. Re-login with knowhow login --jwt.");
-  }
-
-  return jwt;
-}
-
-export async function checkJwt(storedJwt: string, apiUrl: string = KNOWHOW_API_URL) {
-  const response = await http.get(`${apiUrl}/api/users/me`, {
-    headers: {
-      Authorization: `Bearer ${storedJwt}`,
-    },
-  });
-  const user = response.data.user;
-  const orgs = user.orgs;
-  const orgId = response.data.orgId;
-
-  const currentOrg = orgs.find((org: { organizationId: string }) => {
-    return org.organizationId === orgId;
-  });
-
-  return { user, currentOrg };
-}