@hasna/knowledge 0.2.20 → 0.2.22

package/src/service.ts

@@ -1,4 +1,11 @@
 import { createArtifactStore } from './artifact-store';
+import {
+  clearKnowledgeAuth,
+  knowledgeAuthStatus,
+  normalizeKnowledgeApiOrigin,
+  saveKnowledgeAuth,
+  type KnowledgeAuthStatus,
+} from './auth';
 import { runKnowledgePrompt, type KnowledgePromptOptions } from './agent';
 import {
   embeddingIndexStatus,
@@ -14,10 +21,12 @@ import { ingestSourceRef } from './source-ingest';
 import { resolveOpenFilesSource } from './source-resolver';
 import { providerStatus, listModelRegistry, type ProviderStatusResult, type ModelRegistryEntry } from './providers';
 import { enqueueMissingEmbeddings, refreshEmbeddingIndex, reindexHealth, type ReindexRuntimeOptions } from './reindex';
+import { knowledgeRegistryContract, RemoteKnowledgeClient, type RemoteKnowledgeRegistryContract } from './remote-client';
 import { retrieveKnowledgeContext, type RetrievalOptions } from './retrieval';
 import { hybridSearch, type HybridSearchOptions } from './search';
 import { resolveSafetyPolicy } from './safety';
 import { runProviderWebSearch, type WebSearchOptions } from './web-search';
+import { compileWikiPage, fileAnswerToWiki, lintWiki, type WikiCompileOptions } from './wiki-compiler';
 import {
   recordStorageObjects,
   resolveStorageContract,
@@ -30,6 +39,7 @@ import {
   ensureKnowledgeWorkspace,
   readKnowledgeConfig,
   resolveScopedWorkspace,
+  writeKnowledgeConfig,
   type KnowledgeConfig,
   type KnowledgeWorkspace,
 } from './workspace';
@@ -56,6 +66,23 @@ export interface KnowledgePathsResult {
   message: string;
 }
 
+export interface KnowledgeSetupResult {
+  ok: true;
+  mode: KnowledgeConfig['mode'];
+  api_url: string | null;
+  config_path: string;
+  next: string[];
+  message: string;
+}
+
+function normalizeMode(value: string | undefined): KnowledgeConfig['mode'] | undefined {
+  if (!value) return undefined;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'local' || normalized === 'offline') return 'local';
+  if (normalized === 'hosted' || normalized === 'remote' || normalized === 'knowledge.hasna.xyz') return 'hosted';
+  throw new Error('Invalid setup mode. Use hosted or local.');
+}
+
 export class KnowledgeService {
   private ensuredWorkspace?: KnowledgeWorkspace;
   private cachedConfig?: KnowledgeConfig;
@@ -103,6 +130,78 @@ export class KnowledgeService {
     return validateStorageConfig(this.config(), this.ensureWorkspace());
   }
 
+  setup(options: { mode?: string; apiUrl?: string } = {}): KnowledgeSetupResult {
+    const workspace = this.ensureWorkspace();
+    const current = this.config();
+    const mode = normalizeMode(options.mode) ?? current.mode;
+    const apiUrl = options.apiUrl
+      ? normalizeKnowledgeApiOrigin(options.apiUrl)
+      : current.hosted?.api_url
+        ? normalizeKnowledgeApiOrigin(current.hosted.api_url)
+        : null;
+    const nextConfig: KnowledgeConfig = {
+      ...current,
+      mode,
+      hosted: {
+        ...(current.hosted ?? {}),
+        ...(apiUrl ? { api_url: apiUrl } : {}),
+      },
+    };
+    writeKnowledgeConfig(workspace.configPath, nextConfig);
+    this.cachedConfig = nextConfig;
+    return {
+      ok: true,
+      mode,
+      api_url: nextConfig.hosted?.api_url ?? null,
+      config_path: workspace.configPath,
+      next: mode === 'hosted'
+        ? ['open-knowledge auth login --api-key <key>', 'open-knowledge remote contracts --json']
+        : ['open-knowledge search <query>', 'knowledge <prompt>'],
+      message: `Set knowledge mode to ${mode}`,
+    };
+  }
+
+  authStatus(env: Record<string, string | undefined> = process.env): KnowledgeAuthStatus {
+    return knowledgeAuthStatus(this.config(), env);
+  }
+
+  saveAuth(input: {
+    apiKey: string;
+    email?: string;
+    orgId?: string;
+    orgSlug?: string;
+    userId?: string;
+    apiUrl?: string;
+  }, env: Record<string, string | undefined> = process.env) {
+    const apiUrl = input.apiUrl ?? this.config().hosted?.api_url;
+    return saveKnowledgeAuth({
+      api_key: input.apiKey,
+      email: input.email,
+      org_id: input.orgId,
+      org_slug: input.orgSlug,
+      user_id: input.userId,
+      api_url: apiUrl,
+    }, env);
+  }
+
+  clearAuth(env: Record<string, string | undefined> = process.env) {
+    return clearKnowledgeAuth(env);
+  }
+
+  remoteContract(): RemoteKnowledgeRegistryContract {
+    const storage = this.storageContract();
+    return knowledgeRegistryContract({
+      mode: this.config().mode,
+      sourceSchemes: this.config().sources.allowed_schemes,
+      storageType: storage.artifact_store.type,
+      artifactUriPrefix: storage.artifact_store.uri_prefix,
+    });
+  }
+
+  remoteClient(env: Record<string, string | undefined> = process.env): RemoteKnowledgeClient | null {
+    return RemoteKnowledgeClient.fromConfig(this.config(), env);
+  }
+
   paths(): KnowledgePathsResult {
     const workspace = this.ensureWorkspace();
     return {
@@ -147,6 +246,49 @@ export class KnowledgeService {
     return result;
   }
 
+  async compileWiki(options: Omit<WikiCompileOptions, 'dbPath' | 'store'> = {}) {
+    const workspace = this.ensureWorkspace();
+    return compileWikiPage({
+      ...options,
+      dbPath: workspace.knowledgeDbPath,
+      store: this.artifactStore(),
+    });
+  }
+
+  async fileAnswer(options: {
+    prompt: string;
+    answer: string;
+    approveWrite?: boolean;
+    limit?: number;
+    semantic?: boolean;
+    modelRef?: string;
+    dimensions?: number;
+    fake?: boolean;
+  }) {
+    const workspace = this.ensureWorkspace();
+    const context = await this.retrieveContext({
+      query: options.prompt,
+      limit: options.limit,
+      semantic: options.semantic,
+      modelRef: options.modelRef,
+      dimensions: options.dimensions,
+      fake: options.fake,
+    });
+    return fileAnswerToWiki({
+      dbPath: workspace.knowledgeDbPath,
+      store: this.artifactStore(),
+      prompt: options.prompt,
+      answer: options.answer,
+      context,
+      approveWrite: options.approveWrite,
+    });
+  }
+
+  lintWiki() {
+    const workspace = this.ensureWorkspace();
+    return lintWiki({ dbPath: workspace.knowledgeDbPath });
+  }
+
   async ingestManifest(input: string) {
     const workspace = this.ensureWorkspace();
     return ingestOpenFilesManifest({

package/src/storage-contract.ts

@@ -1,5 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import type { Database } from 'bun:sqlite';
+import { DEFAULT_KNOWLEDGE_API_URL, normalizeKnowledgeApiOrigin } from './auth';
+import { REMOTE_KNOWLEDGE_CONTRACT_VERSION } from './remote-client';
 import type { KnowledgeConfig, KnowledgeWorkspace } from './workspace';
 import { HASNA_KNOWLEDGE_APP_PATH } from './workspace';
 
@@ -34,6 +36,15 @@ export interface StorageContract {
       kms_key_configured: boolean;
     } | null;
   };
+  hosted: {
+    enabled: boolean;
+    api_url: string;
+    api_url_env: 'KNOWLEDGE_API_URL';
+    api_key_env: 'KNOWLEDGE_API_KEY';
+    auth_storage: '~/.hasna/knowledge/auth.json';
+    remote_contract_version: typeof REMOTE_KNOWLEDGE_CONTRACT_VERSION;
+    requires_hosted_account_for_local_use: false;
+  };
   source_ownership: {
     owner: 'open-files';
     preferred_ref: string;
@@ -160,6 +171,15 @@ export function resolveStorageContract(
           }
         : null,
     },
+    hosted: {
+      enabled: config.mode === 'hosted',
+      api_url: normalizeKnowledgeApiOrigin(config.hosted?.api_url ?? DEFAULT_KNOWLEDGE_API_URL),
+      api_url_env: 'KNOWLEDGE_API_URL',
+      api_key_env: 'KNOWLEDGE_API_KEY',
+      auth_storage: '~/.hasna/knowledge/auth.json',
+      remote_contract_version: REMOTE_KNOWLEDGE_CONTRACT_VERSION,
+      requires_hosted_account_for_local_use: false,
+    },
     source_ownership: {
       owner: 'open-files',
       preferred_ref: config.sources.preferred_ref,
@@ -219,6 +239,14 @@ export function validateStorageConfig(config: KnowledgeConfig, workspace: Knowle
     errors.push('sources.allowed_schemes must include open-files.');
   }
 
+  if (config.mode === 'hosted' && config.hosted?.api_url) {
+    try {
+      normalizeKnowledgeApiOrigin(config.hosted.api_url);
+    } catch {
+      errors.push('hosted.api_url must be an http(s) URL when mode is hosted.');
+    }
+  }
+
   return {
     ok: errors.length === 0,
     errors,