implement AI labeling to generate description for manifest

Author: florianbgt

deno.json

@@ -6,6 +6,11 @@
   "lock": false,
   "imports": {
     "@inquirer/prompts": "npm:@inquirer/prompts@^7.5.3",
+    "@langchain/anthropic": "npm:@langchain/anthropic@^0.3.23",
+    "@langchain/core": "npm:@langchain/core@^0.3.61",
+    "@langchain/google-genai": "npm:@langchain/google-genai@^0.2.14",
+    "@langchain/langgraph": "npm:@langchain/langgraph@^0.3.5",
+    "@langchain/openai": "npm:@langchain/openai@^0.5.15",
     "@oak/oak": "jsr:@oak/oak@^17.1.4",
     "@std/expect": "jsr:@std/expect@^1.0.16",
     "@std/path": "jsr:@std/path@^1.0.9",

src/cli/handlers/init/index.ts

@@ -20,6 +20,11 @@ import {
 import { ApiService } from "../../../apiService/index.ts";
 import type { globalConfigSchema } from "../../middlewares/globalConfig.ts";
 import { isAuthenticatedMiddleware } from "../../middlewares/isAuthenticated.ts";
+import {
+  ANTHROPIC_PROVIDER,
+  GOOGLE_PROVIDER,
+  OPENAI_PROVIDER,
+} from "../../../manifest/dependencyManifest/labeling/model.ts";
 
 function builder(
   yargs: Arguments & {
@@ -1031,6 +1036,61 @@ export async function generateConfig(
   // Show final file selection to the user
   showFinalFileSelection(workDir, includePatterns, excludePatterns);
 
+  // Labeling configuration
+  console.info("\n🏷️  LABELING CONFIGURATION");
+  console.info(
+    "Labeling helps categorize and organize your code dependencies using AI models.",
+  );
+
+  const enableLabeling = await confirm({
+    message: "Would you like to enable AI-powered labeling?",
+    default: false,
+  });
+
+  let labelingConfig:
+    | z.infer<typeof localConfigSchema>["labeling"]
+    | undefined = undefined;
+
+  if (enableLabeling) {
+    console.info("\n🤖 AI MODEL SELECTION");
+    console.info(
+      "Choose an AI provider for labeling your dependencies:",
+    );
+
+    const modelProvider = await select({
+      message: "Select AI model provider:",
+      choices: [
+        { name: "OpenAI (GPT-4o-mini)", value: OPENAI_PROVIDER },
+        { name: "Google (Gemini 2.5 Flash)", value: GOOGLE_PROVIDER },
+        { name: "Anthropic (Claude 3.5 Sonnet)", value: ANTHROPIC_PROVIDER },
+      ],
+    }) as
+      | typeof OPENAI_PROVIDER
+      | typeof GOOGLE_PROVIDER
+      | typeof ANTHROPIC_PROVIDER;
+
+    const maxConcurrency = await input({
+      message: "Enter maximum concurrent requests (leave empty for unlimited):",
+      validate: (value) => {
+        if (!value.trim()) return true; // Allow empty for unlimited
+        const num = parseInt(value);
+        if (isNaN(num) || num <= 0) {
+          return "Please enter a positive number or leave empty for unlimited";
+        }
+        return true;
+      },
+    });
+
+    labelingConfig = {
+      modelProvider,
+      maxConcurrency: maxConcurrency.trim()
+        ? parseInt(maxConcurrency)
+        : undefined,
+    };
+
+    console.info("✅ Labeling configuration added");
+  }
+
   // Build the config object
   const config: z.infer<typeof localConfigSchema> = {
     language: language,
@@ -1052,5 +1112,10 @@ export async function generateConfig(
     config.c = cConfig;
   }
 
+  // Add labeling config if it exists
+  if (labelingConfig) {
+    config.labeling = labelingConfig;
+  }
+
   return config;
 }

src/cli/handlers/manifest/generate.ts

@@ -45,6 +45,9 @@ function builder(
         }
         return value;
       },
+    }).option("labelingApiKey", {
+      type: "string",
+      description: "The API key to use for the labeling",
     });
 }
 
@@ -128,6 +131,7 @@ async function handler(
     branch?: string;
     commitSha?: string;
     commitShaDate?: string;
+    labelingApiKey?: string;
   },
 ) {
   const napiConfig = argv.napiConfig as z.infer<typeof localConfigSchema>;
@@ -217,7 +221,12 @@ async function handler(
 
     console.info(`📊 Processing ${files.size} files...`);
 
-    const dependencyManifest = generateDependencyManifest(files, napiConfig);
+    const dependencyManifest = await generateDependencyManifest(
+      files,
+      napiConfig,
+      globalConfig,
+      argv.labelingApiKey,
+    );
 
     // Upload manifest to API instead of writing to disk
     const apiService = new ApiService(

src/cli/handlers/set/apiKey.ts

@@ -0,0 +1,53 @@
+import type { Arguments } from "yargs-types";
+import type { z } from "zod";
+import {
+  type globalConfigSchema,
+  setConfig,
+} from "../../middlewares/globalConfig.ts";
+import {
+  ANTHROPIC_PROVIDER,
+  GOOGLE_PROVIDER,
+  type ModelProvider,
+  OPENAI_PROVIDER,
+} from "../../../manifest/dependencyManifest/labeling/model.ts";
+import { input, select } from "@inquirer/prompts";
+
+async function handler(
+  argv: Arguments & {
+    globalConfig: z.infer<typeof globalConfigSchema>;
+  },
+) {
+  const globalConfig = argv.globalConfig as z.infer<typeof globalConfigSchema>;
+
+  const provider = await select({
+    message: "Select a provider",
+    choices: [
+      { name: "Google", value: GOOGLE_PROVIDER },
+      { name: "OpenAI", value: OPENAI_PROVIDER },
+      { name: "Anthropic", value: ANTHROPIC_PROVIDER },
+    ],
+  }) as ModelProvider;
+
+  const apiKey = await input({
+    message: "Enter the API key",
+    validate: (value) => {
+      if (value.length === 0) {
+        return "API key cannot be empty";
+      }
+      return true;
+    },
+  });
+
+  const labeling = globalConfig.labeling || { apiKeys: {} };
+  labeling.apiKeys[provider] = apiKey;
+  setConfig({ ...globalConfig, labeling });
+
+  console.info("API key set successfully");
+}
+
+export default {
+  command: "apiKey",
+  describe: "set an API key for a model provider in your global config",
+  builder: () => {},
+  handler,
+};

src/cli/handlers/set/index.ts

@@ -0,0 +1,21 @@
+import apiKeyHandler from "./apiKey.ts";
+import type { Arguments } from "yargs-types";
+import type { globalConfigSchema } from "../../middlewares/globalConfig.ts";
+import type { z } from "zod";
+
+function builder(
+  yargs: Arguments & {
+    globalConfig: z.infer<typeof globalConfigSchema>;
+  },
+) {
+  return yargs
+    .command(apiKeyHandler)
+    .demandCommand(1, "You need to specify a valid command");
+}
+
+export default {
+  command: "set",
+  describe: "set a value in the global config",
+  builder,
+  handler: () => {},
+};

src/cli/index.ts

@@ -5,6 +5,7 @@ import {
 } from "./middlewares/checkVersion.ts";
 import loginCommand from "./handlers/login/index.ts";
 import initCommand from "./handlers/init/index.ts";
+import setCommand from "./handlers/set/index.ts";
 import manifestCommand from "./handlers/manifest/index.ts";
 import extractCommand from "./handlers/extract/index.ts";
 import { globalConfigMiddleware } from "./middlewares/globalConfig.ts";
@@ -27,6 +28,7 @@ export function initCli() {
     .middleware(globalConfigMiddleware)
     .command(loginCommand)
     .command(initCommand)
+    .command(setCommand)
     .command(manifestCommand)
     .command(extractCommand)
     .demandCommand(1, "You need to specify a command")

src/cli/middlewares/globalConfig.ts

@@ -6,6 +6,13 @@ export const globalConfigSchema = z.object({
   jwt: z.string().optional(),
   token: z.string().optional(),
   apiHost: z.string(),
+  labeling: z.object({
+    apiKeys: z.object({
+      google: z.string().optional(),
+      openai: z.string().optional(),
+      anthropic: z.string().optional(),
+    }),
+  }).optional(),
 });
 
 export const defaultApiHost = "https://api.nanoapi.io";

src/cli/middlewares/napiConfig.ts

@@ -10,6 +10,11 @@ import {
   javaLanguage,
   pythonLanguage,
 } from "../../helpers/treeSitter/parsers.ts";
+import {
+  ANTHROPIC_PROVIDER,
+  GOOGLE_PROVIDER,
+  OPENAI_PROVIDER,
+} from "../../manifest/dependencyManifest/labeling/model.ts";
 
 const pythonVersions = Object.keys(pythonStdlibList);
 
@@ -38,6 +43,14 @@ export const localConfigSchema = z.object({
     exclude: z.array(z.string()).optional(),
   }),
   outDir: z.string(),
+  labeling: z.object({
+    modelProvider: z.enum([
+      GOOGLE_PROVIDER,
+      OPENAI_PROVIDER,
+      ANTHROPIC_PROVIDER,
+    ]),
+    maxConcurrency: z.number().optional(),
+  }).optional(),
 });
 
 const napiConfigFileName = ".napirc";

src/languagePlugins/python/dependencyResolver/index.ts

@@ -126,6 +126,18 @@ export class PythonDependencyResolver {
       const symbolDependencies: SymbolDependency = {
         id: symbol.id,
         type: symbol.type,
+        positions: symbol.nodes.map((node) => ({
+          start: {
+            index: node.startIndex,
+            row: node.startPosition.row,
+            column: node.startPosition.column,
+          },
+          end: {
+            index: node.endIndex,
+            row: node.endPosition.row,
+            column: node.endPosition.column,
+          },
+        })),
         metrics: {
           characterCount: complexityMetrics.characterCount,
           codeCharacterCount: complexityMetrics.codeCharacterCount,

src/languagePlugins/python/dependencyResolver/types.ts

@@ -27,6 +27,19 @@ export interface SymbolDependency {
   id: string;
   /** Symbol type (class, function, variable) */
   type: PythonSymbolType;
+  /** Positions of the symbol in the file */
+  positions: {
+    start: {
+      index: number;
+      row: number;
+      column: number;
+    };
+    end: {
+      index: number;
+      row: number;
+      column: number;
+    };
+  }[];
   /** Size metrics for the symbol */
   metrics: {
     /** Total character count in the symbol */