veryfront 0.1.216 → 0.1.218

package/esm/cli/commands/generate/integration-generator-helpers.d.ts

@@ -0,0 +1,35 @@
+export type TokenAuthMethod = "basic" | "body" | "client_secret_basic" | "client_secret_post" | "request_body";
+export interface IntegrationGeneratorOptionsLike {
+    name?: string;
+    displayName?: string;
+    authType?: "oauth2" | "api-key";
+    apiBaseUrl?: string;
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    scopes?: string;
+    tokenAuthMethod?: TokenAuthMethod;
+    additionalAuthParams?: string;
+    usePKCE?: boolean;
+}
+export interface IntegrationConfig {
+    name: string;
+    displayName: string;
+    authType: "oauth2" | "api-key";
+    apiBaseUrl: string;
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    scopes: string[];
+    tokenAuthMethod: TokenAuthMethod;
+    additionalAuthParams: Record<string, string>;
+    usePKCE: boolean;
+    envVarPrefix: string;
+}
+export declare function parseScopes(scopes?: string): string[];
+export declare function parseAdditionalAuthParams(params?: string): Record<string, string>;
+export declare function normalizeTokenAuthMethod(method?: string): TokenAuthMethod;
+export declare function parseBooleanOption(value: string | boolean | undefined, defaultValue?: boolean): boolean;
+export declare function validateIntegrationName(name: string): void;
+export declare function getNonInteractiveConfig(options: IntegrationGeneratorOptionsLike): IntegrationConfig;
+export declare function getToolInputSchema(toolFile: string): string;
+export declare function getToolExecuteBody(toolFile: string): string;
+//# sourceMappingURL=integration-generator-helpers.d.ts.map

package/esm/cli/commands/generate/integration-generator-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-generator-helpers.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/generate/integration-generator-helpers.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,OAAO,GACP,MAAM,GACN,qBAAqB,GACrB,oBAAoB,GACpB,cAAc,CAAC;AAEnB,MAAM,WAAW,+BAA+B;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,eAAe,EAAE,eAAe,CAAC;IACjC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAErD;AAED,wBAAgB,yBAAyB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BjF;AAED,wBAAgB,wBAAwB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe,CAmBzE;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,EACnC,YAAY,UAAQ,GACnB,OAAO,CAkBT;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAI1D;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,+BAA+B,GACvC,iBAAiB,CAwBnB;AAmCD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/esm/cli/commands/generate/integration-generator-helpers.js

@@ -0,0 +1,123 @@
+export function parseScopes(scopes) {
+    return scopes?.split(",").map((scope) => scope.trim()) || [];
+}
+export function parseAdditionalAuthParams(params) {
+    if (!params?.trim())
+        return {};
+    return Object.fromEntries(params.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map((entry) => {
+        const separatorIndex = entry.indexOf("=");
+        if (separatorIndex === -1) {
+            throw new Error("Additional auth params must use key=value pairs separated by commas");
+        }
+        const key = entry.slice(0, separatorIndex).trim();
+        const value = entry.slice(separatorIndex + 1).trim();
+        if (!key || !value) {
+            throw new Error("Additional auth params must use non-empty key=value pairs");
+        }
+        return [key, value];
+    }));
+}
+export function normalizeTokenAuthMethod(method) {
+    switch (method?.trim().toLowerCase()) {
+        case "basic":
+            return "basic";
+        case "body":
+            return "body";
+        case "client_secret_basic":
+            return "client_secret_basic";
+        case "client_secret_post":
+            return "client_secret_post";
+        case "request_body":
+        case undefined:
+        case "":
+            return "request_body";
+        default:
+            throw new Error("OAuth token auth method must be one of: request_body, body, basic, client_secret_basic, client_secret_post");
+    }
+}
+export function parseBooleanOption(value, defaultValue = false) {
+    if (typeof value === "boolean")
+        return value;
+    if (!value?.trim())
+        return defaultValue;
+    switch (value.trim().toLowerCase()) {
+        case "y":
+        case "yes":
+        case "true":
+        case "1":
+            return true;
+        case "n":
+        case "no":
+        case "false":
+        case "0":
+            return false;
+        default:
+            throw new Error("Boolean option must be yes/no, true/false, or 1/0");
+    }
+}
+export function validateIntegrationName(name) {
+    if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) {
+        throw new Error("Integration name must be lowercase letters, numbers, and hyphens");
+    }
+}
+export function getNonInteractiveConfig(options) {
+    const { name, displayName, authType } = options;
+    if (!name || !displayName || !authType) {
+        throw new Error("Non-interactive mode requires --name, --display-name, and --auth-type options");
+    }
+    const normalizedName = name.toLowerCase();
+    return {
+        name: normalizedName,
+        displayName,
+        authType,
+        apiBaseUrl: options.apiBaseUrl ?? `https://api.${name}.com`,
+        authorizationUrl: options.authorizationUrl,
+        tokenUrl: options.tokenUrl,
+        scopes: parseScopes(options.scopes),
+        tokenAuthMethod: normalizeTokenAuthMethod(options.tokenAuthMethod),
+        additionalAuthParams: parseAdditionalAuthParams(options.additionalAuthParams),
+        usePKCE: parseBooleanOption(options.usePKCE, false),
+        envVarPrefix: name.toUpperCase().replace(/-/g, "_"),
+    };
+}
+const TOOL_FILE_CONTENTS = {
+    "list-items.ts": {
+        inputSchema: `limit: z.number().optional().describe("Maximum number of items to return"),
+    offset: z.number().optional().describe("Number of items to skip"),`,
+        executeBody: `const items = await listItems({
+        limit: input.limit,
+        offset: input.offset,
+      });
+      return {
+        success: true,
+        items,
+        count: items.length,
+      };`,
+    },
+    "get-item.ts": {
+        inputSchema: `id: z.string().describe("The ID of the item to retrieve"),`,
+        executeBody: `const item = await getItem(input.id);
+      return {
+        success: true,
+        item,
+      };`,
+    },
+    "search.ts": {
+        inputSchema: `query: z.string().describe("Search query"),`,
+        executeBody: `const results = await searchItems(input.query);
+      return {
+        success: true,
+        results,
+        count: results.length,
+      };`,
+    },
+};
+export function getToolInputSchema(toolFile) {
+    return TOOL_FILE_CONTENTS[toolFile]?.inputSchema ?? "";
+}
+export function getToolExecuteBody(toolFile) {
+    return TOOL_FILE_CONTENTS[toolFile]?.executeBody ?? "";
+}

package/esm/cli/commands/generate/integration-generator.d.ts

@@ -4,6 +4,7 @@
  * Generates new service integration scaffolds with interactive prompts.
  * Creates connector.json, API client, OAuth routes, token store, and tool skeletons.
  */
+import { type TokenAuthMethod } from "./integration-generator-helpers.js";
 export interface IntegrationGeneratorOptions {
     /** Integration name (lowercase, e.g., "twilio") */
     name?: string;
@@ -28,7 +29,5 @@ export interface IntegrationGeneratorOptions {
     /** Skip interactive prompts */
     skipPrompts?: boolean;
 }
-type TokenAuthMethod = "basic" | "body" | "client_secret_basic" | "client_secret_post" | "request_body";
 export declare function generateIntegration(projectDir: string, options?: IntegrationGeneratorOptions): Promise<void>;
-export {};
 //# sourceMappingURL=integration-generator.d.ts.map

package/esm/cli/commands/generate/integration-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integration-generator.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/generate/integration-generator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAaH,MAAM,WAAW,2BAA2B;IAC1C,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,mBAAmB;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,yEAAyE;IACzE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,oDAAoD;IACpD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,+BAA+B;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,KAAK,eAAe,GAChB,OAAO,GACP,MAAM,GACN,qBAAqB,GACrB,oBAAoB,GACpB,cAAc,CAAC;AA2GnB,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,IAAI,CAAC,CAwBf"}
+{"version":3,"file":"integration-generator.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/generate/integration-generator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,EASL,KAAK,eAAe,EAErB,MAAM,oCAAoC,CAAC;AAK5C,MAAM,WAAW,2BAA2B;IAC1C,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,mBAAmB;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,yEAAyE;IACzE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,oDAAoD;IACpD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,+BAA+B;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAaD,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,IAAI,CAAC,CAwBf"}

package/esm/cli/commands/generate/integration-generator.js

@@ -11,6 +11,7 @@ import { createFileSystem } from "../../../src/platform/index.js";
 import { ensureDir } from "../../utils/fs.js";
 import { isInteractive as checkIsInteractive, promptSync } from "../../../src/platform/index.js";
 import { isCiEnv, isDenoTestingEnv } from "../../../src/config/index.js";
+import { getNonInteractiveConfig, getToolExecuteBody, getToolInputSchema, normalizeTokenAuthMethod, parseAdditionalAuthParams, parseBooleanOption, parseScopes, validateIntegrationName, } from "./integration-generator-helpers.js";
 import { select } from "../../utils/terminal-select.js";
 let fs;
 function canRunPrompts() {
@@ -22,71 +23,6 @@ function promptText(question, defaultValue) {
     const input = promptSync(fullQuestion);
     return Promise.resolve(input?.trim() || defaultValue || "");
 }
-function parseScopes(scopes) {
-    return scopes?.split(",").map((s) => s.trim()) || [];
-}
-function parseAdditionalAuthParams(params) {
-    if (!params?.trim())
-        return {};
-    return Object.fromEntries(params.split(",")
-        .map((entry) => entry.trim())
-        .filter(Boolean)
-        .map((entry) => {
-        const separatorIndex = entry.indexOf("=");
-        if (separatorIndex === -1) {
-            throw new Error("Additional auth params must use key=value pairs separated by commas");
-        }
-        const key = entry.slice(0, separatorIndex).trim();
-        const value = entry.slice(separatorIndex + 1).trim();
-        if (!key || !value) {
-            throw new Error("Additional auth params must use non-empty key=value pairs");
-        }
-        return [key, value];
-    }));
-}
-function normalizeTokenAuthMethod(method) {
-    switch (method?.trim().toLowerCase()) {
-        case "basic":
-            return "basic";
-        case "body":
-            return "body";
-        case "client_secret_basic":
-            return "client_secret_basic";
-        case "client_secret_post":
-            return "client_secret_post";
-        case "request_body":
-        case undefined:
-        case "":
-            return "request_body";
-        default:
-            throw new Error("OAuth token auth method must be one of: request_body, body, basic, client_secret_basic, client_secret_post");
-    }
-}
-function parseBooleanOption(value, defaultValue = false) {
-    if (typeof value === "boolean")
-        return value;
-    if (!value?.trim())
-        return defaultValue;
-    switch (value.trim().toLowerCase()) {
-        case "y":
-        case "yes":
-        case "true":
-        case "1":
-            return true;
-        case "n":
-        case "no":
-        case "false":
-        case "0":
-            return false;
-        default:
-            throw new Error("Boolean option must be yes/no, true/false, or 1/0");
-    }
-}
-function validateIntegrationName(name) {
-    if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) {
-        throw new Error("Integration name must be lowercase letters, numbers, and hyphens");
-    }
-}
 export async function generateIntegration(projectDir, options = {}) {
     fs = createFileSystem();
     const shouldPrompt = !options.skipPrompts && canRunPrompts();
@@ -109,26 +45,6 @@ export async function generateIntegration(projectDir, options = {}) {
     console.log(`  4. Customize the generated tools in ai/integrations/${config.name}/tools/`);
     console.log("");
 }
-function getNonInteractiveConfig(options) {
-    const { name, displayName, authType } = options;
-    if (!name || !displayName || !authType) {
-        throw new Error("Non-interactive mode requires --name, --display-name, and --auth-type options");
-    }
-    const normalizedName = name.toLowerCase();
-    return {
-        name: normalizedName,
-        displayName,
-        authType,
-        apiBaseUrl: options.apiBaseUrl ?? `https://api.${name}.com`,
-        authorizationUrl: options.authorizationUrl,
-        tokenUrl: options.tokenUrl,
-        scopes: parseScopes(options.scopes),
-        tokenAuthMethod: normalizeTokenAuthMethod(options.tokenAuthMethod),
-        additionalAuthParams: parseAdditionalAuthParams(options.additionalAuthParams),
-        usePKCE: parseBooleanOption(options.usePKCE, false),
-        envVarPrefix: name.toUpperCase().replace(/-/g, "_"),
-    };
-}
 async function getInteractiveConfig(options) {
     console.log("");
     console.log(green("Integration Generator"));
@@ -666,44 +582,6 @@ export async function searchItems(query: string): Promise<unknown[]> {
     await fs.writeTextFile(join(baseDir, "lib", `${config.name}-client.ts`), client);
     cliLogger.debug("Created API client");
 }
-function getToolInputSchema(toolFile) {
-    return TOOL_FILE_CONTENTS[toolFile]?.inputSchema ?? "";
-}
-function getToolExecuteBody(toolFile) {
-    return TOOL_FILE_CONTENTS[toolFile]?.executeBody ?? "";
-}
-const TOOL_FILE_CONTENTS = {
-    "list-items.ts": {
-        inputSchema: `limit: z.number().optional().describe("Maximum number of items to return"),
-    offset: z.number().optional().describe("Number of items to skip"),`,
-        executeBody: `const items = await listItems({
-        limit: input.limit,
-        offset: input.offset,
-      });
-      return {
-        success: true,
-        items,
-        count: items.length,
-      };`,
-    },
-    "get-item.ts": {
-        inputSchema: `id: z.string().describe("The ID of the item to retrieve"),`,
-        executeBody: `const item = await getItem(input.id);
-      return {
-        success: true,
-        item,
-      };`,
-    },
-    "search.ts": {
-        inputSchema: `query: z.string().describe("Search query"),`,
-        executeBody: `const results = await searchItems(input.query);
-      return {
-        success: true,
-        results,
-        count: results.length,
-      };`,
-    },
-};
 async function createToolSkeletons(baseDir, config) {
     const tools = [
         {

package/esm/cli/commands/knowledge/command-helpers.d.ts

@@ -0,0 +1,48 @@
+import type { KnowledgeIngestFailedFileResult, KnowledgeIngestFileResult, KnowledgeIngestSkippedFileResult } from "./result.js";
+export type KnowledgeSource = {
+    kind: "local";
+    input: string;
+    localPath: string;
+} | {
+    kind: "upload";
+    input: string;
+    uploadPath: string;
+    localPath: string;
+};
+export interface KnowledgeSourceCollection {
+    sources: KnowledgeSource[];
+    skipped: KnowledgeIngestSkippedFileResult[];
+}
+export declare function normalizeKnowledgeInputPath(inputPath: string): string;
+export declare function normalizeProjectUploadPath(inputPath: string): string;
+export declare function formatKnowledgeUploadSource(uploadPath: string): string;
+export declare function resolveExplicitUploadPath(inputPath: string): string;
+export declare function isLikelyLocalPath(value: string): boolean;
+export declare function isProjectUploadReference(value: string): boolean;
+export declare function stripChatUploadPrefix(name: string): string;
+export declare function resolveKnowledgeDownloadOutputDir(outputDir: string): string;
+export declare function createFailedKnowledgeSource(input: {
+    source: string;
+    localSourcePath: string;
+    message: string;
+    reason: KnowledgeIngestFailedFileResult["reason"];
+}): KnowledgeIngestFailedFileResult;
+export declare function collectLocalFiles(root: string, recursive: boolean): Promise<KnowledgeSourceCollection>;
+export declare function buildSourceReference(source: KnowledgeSource): string;
+export declare function buildSuggestedSlug(source: KnowledgeSource, index: number): string;
+export declare function ensureUniqueSlugs(sources: KnowledgeSource[]): string[];
+export declare function deriveKnowledgeRemotePath(outputPath: string, outputDir: string, knowledgePath: string): string;
+export declare function createKnowledgeIngestResult(input: {
+    source: string;
+    localSourcePath: string;
+    outputPath: string;
+    remotePath: string;
+    parser: {
+        slug: string;
+        stats: Record<string, unknown>;
+        warnings: string[];
+        source_type: string;
+        summary: string;
+    };
+}): KnowledgeIngestFileResult;
+//# sourceMappingURL=command-helpers.d.ts.map

package/esm/cli/commands/knowledge/command-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-helpers.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/knowledge/command-helpers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,+BAA+B,EAC/B,yBAAyB,EACzB,gCAAgC,EACjC,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7E,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,OAAO,EAAE,gCAAgC,EAAE,CAAC;CAC7C;AASD,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAMrE;AAED,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAKtE;AAED,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAanE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAI/D;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,iCAAiC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3E;AAgBD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,+BAA+B,CAAC,QAAQ,CAAC,CAAC;CACnD,GAAG,+BAA+B,CAOlC;AAmCD,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,yBAAyB,CAAC,CA8DpC;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAIpE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAgCjF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,EAAE,CAQtE;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GACpB,MAAM,CAQR;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH,GAAG,yBAAyB,CAY5B"}

package/esm/cli/commands/knowledge/command-helpers.js

@@ -0,0 +1,216 @@
+import { createFileSystem } from "../../../src/platform/index.js";
+import { basename, extname, join, normalize, relative } from "../../../src/platform/compat/path/index.js";
+import { classifyKnowledgeDirectoryPath, classifyKnowledgeSourcePath } from "./source-policy.js";
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "document";
+}
+const CHAT_UPLOAD_PREFIX_RE = /^chat-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}-\d+-[a-z0-9]+-/i;
+export function normalizeKnowledgeInputPath(inputPath) {
+    const normalizedPath = normalize(inputPath).replace(/^\/+/, "").replace(/\\/g, "/");
+    if (!normalizedPath || normalizedPath.startsWith("..") || normalizedPath.startsWith("/")) {
+        throw new Error(`Invalid knowledge input path: ${inputPath}`);
+    }
+    return normalizedPath;
+}
+export function normalizeProjectUploadPath(inputPath) {
+    return normalizeKnowledgeInputPath(inputPath);
+}
+export function formatKnowledgeUploadSource(uploadPath) {
+    const normalizedPath = normalizeKnowledgeInputPath(uploadPath);
+    return normalizedPath === "uploads" || normalizedPath.startsWith("uploads/")
+        ? normalizedPath
+        : `uploads/${normalizedPath}`;
+}
+export function resolveExplicitUploadPath(inputPath) {
+    const normalizedInput = normalizeKnowledgeInputPath(inputPath);
+    const displayInput = inputPath.replace(/\\/g, "/");
+    const uploadPath = normalizeProjectUploadPath(inputPath);
+    if (!uploadPath || uploadPath === "uploads" || normalizedInput === "uploads" ||
+        normalizedInput.endsWith("/")) {
+        throw new Error(`Directory upload references require --path <prefix> --all: ${displayInput}`);
+    }
+    return uploadPath;
+}
+export function isLikelyLocalPath(value) {
+    return value.startsWith("/") || value.startsWith("./") || value.startsWith("../") ||
+        /^[A-Za-z]:[\\/]/.test(value);
+}
+export function isProjectUploadReference(value) {
+    if (isLikelyLocalPath(value))
+        return false;
+    const normalizedValue = normalize(value).replace(/\\/g, "/").replace(/^\/+/, "");
+    return normalizedValue === "uploads" || normalizedValue.startsWith("uploads/");
+}
+export function stripChatUploadPrefix(name) {
+    return name.replace(CHAT_UPLOAD_PREFIX_RE, "");
+}
+export function resolveKnowledgeDownloadOutputDir(outputDir) {
+    return join(outputDir, ".uploads");
+}
+function createSkippedKnowledgeSource(input) {
+    return {
+        source: input.source,
+        localSourcePath: input.localSourcePath ?? null,
+        message: input.message,
+        reason: input.reason,
+    };
+}
+export function createFailedKnowledgeSource(input) {
+    return {
+        source: input.source,
+        localSourcePath: input.localSourcePath,
+        message: input.message,
+        reason: input.reason,
+    };
+}
+function classifySourceOrSkip(input) {
+    const decision = classifyKnowledgeSourcePath(input.source);
+    if (decision.kind === "ingest") {
+        return null;
+    }
+    return createSkippedKnowledgeSource({
+        source: input.source,
+        localSourcePath: input.localSourcePath,
+        message: decision.message,
+        reason: decision.reason,
+    });
+}
+function classifyDirectoryOrSkip(input) {
+    const decision = classifyKnowledgeDirectoryPath(input.source);
+    if (decision.kind === "ingest") {
+        return null;
+    }
+    return createSkippedKnowledgeSource({
+        source: input.source,
+        localSourcePath: null,
+        message: decision.message,
+        reason: decision.reason,
+    });
+}
+export async function collectLocalFiles(root, recursive) {
+    const fs = createFileSystem();
+    const stat = await fs.stat(root);
+    if (stat.isFile) {
+        const skipped = classifySourceOrSkip({ source: root, localSourcePath: root });
+        return skipped == null
+            ? {
+                sources: [{ kind: "local", input: root, localPath: root }],
+                skipped: [],
+            }
+            : {
+                sources: [],
+                skipped: [skipped],
+            };
+    }
+    if (!stat.isDirectory) {
+        return { sources: [], skipped: [] };
+    }
+    const skippedRootDirectory = classifyDirectoryOrSkip({ source: root });
+    if (skippedRootDirectory != null) {
+        return {
+            sources: [],
+            skipped: [skippedRootDirectory],
+        };
+    }
+    const collection = {
+        sources: [],
+        skipped: [],
+    };
+    async function walk(dir) {
+        for await (const entry of fs.readDir(dir)) {
+            const entryPath = join(dir, entry.name);
+            if (entry.isDirectory) {
+                const skipped = classifyDirectoryOrSkip({ source: entryPath });
+                if (skipped != null) {
+                    collection.skipped.push(skipped);
+                    continue;
+                }
+                if (recursive)
+                    await walk(entryPath);
+                continue;
+            }
+            if (!entry.isFile) {
+                continue;
+            }
+            const skipped = classifySourceOrSkip({ source: entryPath, localSourcePath: entryPath });
+            if (skipped != null) {
+                collection.skipped.push(skipped);
+                continue;
+            }
+            collection.sources.push({ kind: "local", input: root, localPath: entryPath });
+        }
+    }
+    await walk(root);
+    collection.sources.sort((left, right) => left.localPath.localeCompare(right.localPath));
+    collection.skipped.sort((left, right) => left.source.localeCompare(right.source));
+    return collection;
+}
+export function buildSourceReference(source) {
+    return source.kind === "upload"
+        ? formatKnowledgeUploadSource(source.uploadPath)
+        : source.localPath;
+}
+export function buildSuggestedSlug(source, index) {
+    const normalized = normalize(source.kind === "upload" ? source.uploadPath : source.localPath).replace(/\\/g, "/");
+    let stripped;
+    if (source.kind === "upload") {
+        stripped = normalized
+            .replace(/^\/workspace\/uploads\//, "")
+            .replace(/^\/workspace\//, "")
+            .replace(/^uploads\//, "")
+            .replace(/\.[^.]+$/, "");
+    }
+    else if (normalized.startsWith("/workspace/uploads/")) {
+        stripped = normalized.replace(/^\/workspace\/uploads\//, "").replace(/\.[^.]+$/, "");
+    }
+    else if (normalized.startsWith("/workspace/")) {
+        stripped = normalized.replace(/^\/workspace\//, "").replace(/\.[^.]+$/, "");
+    }
+    else if (normalized.startsWith("/")) {
+        stripped = basename(normalized, extname(normalized));
+    }
+    else {
+        stripped = normalized.replace(/\.[^.]+$/, "");
+    }
+    const lastSlash = stripped.lastIndexOf("/");
+    if (lastSlash >= 0) {
+        const dir = stripped.slice(0, lastSlash + 1);
+        const file = stripChatUploadPrefix(stripped.slice(lastSlash + 1));
+        stripped = file ? `${dir}${file}` : stripped;
+    }
+    else {
+        stripped = stripChatUploadPrefix(stripped) || stripped;
+    }
+    return slugify(stripped || basename(normalized, extname(normalized)) || `document-${index + 1}`);
+}
+export function ensureUniqueSlugs(sources) {
+    const counts = new Map();
+    return sources.map((source, index) => {
+        const baseSlug = buildSuggestedSlug(source, index);
+        const nextCount = (counts.get(baseSlug) ?? 0) + 1;
+        counts.set(baseSlug, nextCount);
+        return nextCount === 1 ? baseSlug : `${baseSlug}-${nextCount}`;
+    });
+}
+export function deriveKnowledgeRemotePath(outputPath, outputDir, knowledgePath) {
+    const relativeOutputPath = relative(outputDir, outputPath).replace(/\\/g, "/");
+    if (!relativeOutputPath || relativeOutputPath.startsWith("..")) {
+        throw new Error(`Output path is outside output directory: ${outputPath}`);
+    }
+    const prefix = normalizeKnowledgeInputPath(knowledgePath);
+    const normalizedRelative = normalize(relativeOutputPath).replace(/^\/+/, "");
+    return `${prefix}/${normalizedRelative}`.replace(/\\/g, "/");
+}
+export function createKnowledgeIngestResult(input) {
+    return {
+        source: input.source,
+        localSourcePath: input.localSourcePath,
+        outputPath: input.outputPath,
+        remotePath: input.remotePath,
+        slug: input.parser.slug,
+        sourceType: input.parser.source_type,
+        summary: input.parser.summary,
+        stats: input.parser.stats,
+        warnings: input.parser.warnings,
+    };
+}

package/esm/cli/commands/knowledge/command.d.ts

@@ -9,6 +9,7 @@ type SafeParseResult<T> = {
 import { type CommandResult } from "../../../src/platform/index.js";
 import { type ApiClient } from "../../shared/config.js";
 import type { ParsedArgs } from "../../shared/types.js";
+import * as commandHelpers from "./command-helpers.js";
 import { type Logger } from "../../../src/utils/index.js";
 import { type KnowledgeIngestFailedFileResult, type KnowledgeIngestFileResult, type KnowledgeIngestSkippedFileResult } from "./result.js";
 export interface KnowledgeParserResult {
@@ -66,22 +67,16 @@ declare const KnowledgeIngestArgsSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type KnowledgeIngestOptions = z.infer<typeof KnowledgeIngestArgsSchema>;
 export declare function parseKnowledgeIngestArgs(args: ParsedArgs): SafeParseResult<KnowledgeIngestOptions>;
-export declare function normalizeKnowledgeInputPath(inputPath: string): string;
-export declare function normalizeProjectUploadPath(inputPath: string): string;
-export declare function formatKnowledgeUploadSource(uploadPath: string): string;
-export declare function isLikelyLocalPath(value: string): boolean;
-export declare function stripChatUploadPrefix(name: string): string;
-export declare function resolveKnowledgeDownloadOutputDir(outputDir: string): string;
-export declare function buildSuggestedSlug(source: KnowledgeSource, index: number): string;
-export declare function ensureUniqueSlugs(sources: KnowledgeSource[]): string[];
-export declare function deriveKnowledgeRemotePath(outputPath: string, outputDir: string, knowledgePath: string): string;
-export declare function createKnowledgeIngestResult(input: {
-    source: string;
-    localSourcePath: string;
-    outputPath: string;
-    remotePath: string;
-    parser: Pick<KnowledgeParserResult, "slug" | "stats" | "warnings" | "source_type" | "summary">;
-}): KnowledgeIngestFileResult;
+export declare const normalizeKnowledgeInputPath: typeof commandHelpers.normalizeKnowledgeInputPath;
+export declare const normalizeProjectUploadPath: typeof commandHelpers.normalizeProjectUploadPath;
+export declare const formatKnowledgeUploadSource: typeof commandHelpers.formatKnowledgeUploadSource;
+export declare const isLikelyLocalPath: typeof commandHelpers.isLikelyLocalPath;
+export declare const stripChatUploadPrefix: typeof commandHelpers.stripChatUploadPrefix;
+export declare const resolveKnowledgeDownloadOutputDir: typeof commandHelpers.resolveKnowledgeDownloadOutputDir;
+export declare const buildSuggestedSlug: typeof commandHelpers.buildSuggestedSlug;
+export declare const ensureUniqueSlugs: typeof commandHelpers.ensureUniqueSlugs;
+export declare const deriveKnowledgeRemotePath: typeof commandHelpers.deriveKnowledgeRemotePath;
+export declare const createKnowledgeIngestResult: typeof commandHelpers.createKnowledgeIngestResult;
 export declare function runKnowledgeParser(input: {
     filePath: string;
     outputDir: string;