mirror of
https://github.com/QwenLM/qwen-code.git
synced 2025-12-20 16:57:46 +00:00
Starting to modularize into separate cli / server packages. (#55)
* Starting to move a lot of code into packages/server * More of the massive refactor, builds and runs, some issues though. * Fixing outstanding issue with double messages. * Fixing a minor UI issue. * Fixing the build post-merge. * Running formatting. * Addressing comments.
This commit is contained in:
Evan Senter
GitHub
@@ -4,16 +4,27 @@
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import { Content, SchemaUnion, Type } from '@google/genai';
|
||||
import {
|
||||
Config,
|
||||
getErrorMessage,
|
||||
isNodeError,
|
||||
GeminiClient,
|
||||
} from '@gemini-code/server';
|
||||
import { promises as fs } from 'fs';
|
||||
import { Content, SchemaUnion, Type } from '@google/genai'; // Assuming these types exist
|
||||
import { GeminiClient } from '../core/gemini-client.js'; // Assuming this path
|
||||
import { exec } from 'child_process'; // Needed for Windows process check
|
||||
import { promisify } from 'util'; // To promisify exec
|
||||
import { globalConfig } from '../config/config.js';
|
||||
import { getErrorMessage, isNodeError } from './errors.js';
|
||||
import { exec as _exec } from 'child_process';
|
||||
import { promisify } from 'util';
|
||||
|
||||
// Define the AnalysisStatus type alias
|
||||
type AnalysisStatus =
|
||||
| 'Running'
|
||||
| 'SuccessReported'
|
||||
| 'ErrorReported'
|
||||
| 'Unknown'
|
||||
| 'AnalysisFailed';
|
||||
|
||||
// Promisify child_process.exec for easier async/await usage
|
||||
const execAsync = promisify(exec);
|
||||
const execAsync = promisify(_exec);
|
||||
|
||||
// Define the expected interface for the AI client dependency
|
||||
export interface AiClient {
|
||||
@@ -49,27 +60,39 @@ function isAnalysisFailure(
|
||||
|
||||
// Represents the final outcome after polling is complete (or failed/timed out)
|
||||
export interface FinalAnalysisOutcome {
|
||||
status: string; // e.g., 'SuccessReported', 'ErrorReported', 'ProcessEnded_SuccessReported', 'TimedOut_Running', 'AnalysisFailed'
|
||||
status: string; // e.g., 'Completed_SuccessReported', 'TimedOut_Running', 'AnalysisFailed'
|
||||
summary: string; // Final summary or error message
|
||||
}
|
||||
|
||||
export class BackgroundTerminalAnalyzer {
|
||||
private ai: AiClient;
|
||||
// Make polling parameters configurable via constructor
|
||||
private geminiClient: GeminiClient | null = null;
|
||||
private readonly maxOutputAnalysisLength = 20000;
|
||||
private pollIntervalMs: number;
|
||||
private maxAttempts: number;
|
||||
private initialDelayMs: number;
|
||||
|
||||
// --- Dependency Injection & Configuration ---
|
||||
constructor(
|
||||
aiClient?: AiClient, // Allow injecting AiClient, default to GeminiClient
|
||||
config: Config, // Accept Config object
|
||||
options: {
|
||||
pollIntervalMs?: number;
|
||||
maxAttempts?: number;
|
||||
initialDelayMs?: number;
|
||||
} = {}, // Provide default options
|
||||
} = {},
|
||||
) {
|
||||
this.ai = aiClient || new GeminiClient(globalConfig); // Call constructor without model
|
||||
try {
|
||||
// Initialize Gemini client using config
|
||||
this.geminiClient = new GeminiClient(
|
||||
config.getApiKey(),
|
||||
config.getModel(),
|
||||
);
|
||||
} catch (error) {
|
||||
console.error(
|
||||
'Failed to initialize GeminiClient in BackgroundTerminalAnalyzer:',
|
||||
error,
|
||||
);
|
||||
// Set client to null so analyzeOutput handles it
|
||||
this.geminiClient = null;
|
||||
}
|
||||
this.pollIntervalMs = options.pollIntervalMs ?? 5000; // Default 5 seconds
|
||||
this.maxAttempts = options.maxAttempts ?? 6; // Default 6 attempts (approx 30s total)
|
||||
this.initialDelayMs = options.initialDelayMs ?? 500; // Default 0.5s initial delay
|
||||
@@ -90,6 +113,17 @@ export class BackgroundTerminalAnalyzer {
|
||||
tempStderrFilePath: string,
|
||||
command: string,
|
||||
): Promise<FinalAnalysisOutcome> {
|
||||
// --- Validate PID ---
|
||||
if (typeof pid !== 'number' || !Number.isInteger(pid) || pid <= 0) {
|
||||
console.error(
|
||||
`BackgroundTerminalAnalyzer: Invalid or non-numeric PID provided (${pid}). Analysis cannot proceed.`,
|
||||
);
|
||||
return {
|
||||
status: 'AnalysisFailed',
|
||||
summary: 'Invalid PID provided for analysis.',
|
||||
};
|
||||
}
|
||||
|
||||
// --- Initial Delay ---
|
||||
// Wait briefly before the first check to allow the process to initialize
|
||||
// and potentially write initial output.
|
||||
@@ -142,21 +176,22 @@ export class BackgroundTerminalAnalyzer {
|
||||
/* ignore */
|
||||
}
|
||||
|
||||
lastAnalysisResult = await this.analyzeOutputWithLLM(
|
||||
lastAnalysisResult = await this.performLlmAnalysis(
|
||||
currentStdout,
|
||||
currentStderr,
|
||||
command,
|
||||
pid,
|
||||
);
|
||||
|
||||
if (isAnalysisFailure(lastAnalysisResult)) {
|
||||
return {
|
||||
status: 'ProcessEnded_AnalysisFailed',
|
||||
status: 'Completed_AnalysisFailed',
|
||||
summary: `Process ended. Final analysis failed: ${lastAnalysisResult.error}`,
|
||||
};
|
||||
}
|
||||
// Append ProcessEnded to the status determined by the final analysis
|
||||
return {
|
||||
status: 'ProcessEnded_' + lastAnalysisResult.inferredStatus,
|
||||
status: 'Completed_' + lastAnalysisResult.inferredStatus,
|
||||
summary: `Process ended. Final analysis summary: ${lastAnalysisResult.summary}`,
|
||||
};
|
||||
}
|
||||
@@ -170,10 +205,11 @@ export class BackgroundTerminalAnalyzer {
|
||||
}
|
||||
|
||||
// --- LLM Analysis ---
|
||||
lastAnalysisResult = await this.analyzeOutputWithLLM(
|
||||
lastAnalysisResult = await this.performLlmAnalysis(
|
||||
currentStdout,
|
||||
currentStderr,
|
||||
command,
|
||||
pid,
|
||||
);
|
||||
|
||||
if (isAnalysisFailure(lastAnalysisResult)) {
|
||||
@@ -293,31 +329,31 @@ export class BackgroundTerminalAnalyzer {
|
||||
}
|
||||
|
||||
// --- LLM Analysis Method (largely unchanged but added validation robustness) ---
|
||||
private async analyzeOutputWithLLM(
|
||||
stdout: string,
|
||||
stderr: string,
|
||||
private async performLlmAnalysis(
|
||||
stdoutContent: string,
|
||||
stderrContent: string,
|
||||
command: string,
|
||||
pid: number,
|
||||
): Promise<AnalysisResult | AnalysisFailure> {
|
||||
try {
|
||||
const schema: SchemaUnion = {
|
||||
/* ... schema definition remains the same ... */ type: Type.OBJECT,
|
||||
properties: {
|
||||
summary: {
|
||||
type: Type.STRING,
|
||||
description:
|
||||
"A concise interpretation of significant events, progress, final results, or errors found in the process's stdout and stderr. Summarizes what the logs indicate happened. Should be formatted as markdown.",
|
||||
},
|
||||
inferredStatus: {
|
||||
type: Type.STRING,
|
||||
description:
|
||||
"The inferred status based *only* on analyzing the provided log content. Possible values: 'Running' (logs show ongoing activity without completion/error), 'SuccessReported' (logs indicate successful completion or final positive result), 'ErrorReported' (logs indicate an error or failure), 'Unknown' (status cannot be clearly determined from the log content).",
|
||||
enum: ['Running', 'SuccessReported', 'ErrorReported', 'Unknown'],
|
||||
},
|
||||
},
|
||||
required: ['summary', 'inferredStatus'],
|
||||
if (!this.geminiClient) {
|
||||
return {
|
||||
error: '[Analysis unavailable: Gemini client not initialized]',
|
||||
inferredStatus: 'AnalysisFailed',
|
||||
};
|
||||
}
|
||||
|
||||
const prompt = `**Analyze Background Process Logs**
|
||||
const truncatedStdout =
|
||||
stdoutContent.substring(0, this.maxOutputAnalysisLength) +
|
||||
(stdoutContent.length > this.maxOutputAnalysisLength
|
||||
? '... [truncated]'
|
||||
: '');
|
||||
const truncatedStderr =
|
||||
stderrContent.substring(0, this.maxOutputAnalysisLength) +
|
||||
(stderrContent.length > this.maxOutputAnalysisLength
|
||||
? '... [truncated]'
|
||||
: '');
|
||||
|
||||
const analysisPrompt = `**Analyze Background Process Logs**
|
||||
|
||||
**Context:** A command (\`${command}\`) was executed in the background. You are analyzing the standard output (stdout) and standard error (stderr) collected so far to understand its progress and outcome. This analysis will be used to inform a user about what the command did.
|
||||
|
||||
@@ -325,11 +361,11 @@ export class BackgroundTerminalAnalyzer {
|
||||
* **Command:** \`${command}\`
|
||||
* **Stdout:**
|
||||
\`\`\`
|
||||
${stdout.slice(-2000) || '(empty)'} ${stdout.length > 2000 ? '\n... (truncated)' : ''}
|
||||
${truncatedStdout}
|
||||
\`\`\`
|
||||
* **Stderr:**
|
||||
\`\`\`
|
||||
${stderr.slice(-2000) || '(empty)'} ${stderr.length > 2000 ? '\n... (truncated)' : ''}
|
||||
${truncatedStderr}
|
||||
\`\`\`
|
||||
|
||||
**Task:**
|
||||
@@ -354,12 +390,14 @@ Based *only* on the provided stdout and stderr:
|
||||
properties: {
|
||||
summary: {
|
||||
type: 'string',
|
||||
description: 'Concise markdown summary of log interpretation.',
|
||||
description:
|
||||
'Concise markdown summary (1-3 sentences) of log interpretation.',
|
||||
},
|
||||
inferredStatus: {
|
||||
type: 'string',
|
||||
enum: ['Running', 'SuccessReported', 'ErrorReported', 'Unknown'],
|
||||
description: 'Status inferred *only* from log content.',
|
||||
description:
|
||||
'Status inferred from logs: Running, SuccessReported, ErrorReported, Unknown',
|
||||
},
|
||||
},
|
||||
required: ['summary', 'inferredStatus'],
|
||||
@@ -373,57 +411,63 @@ Based *only* on the provided stdout and stderr:
|
||||
* The \`summary\` must be an interpretation of the logs, focusing on key outcomes or activities. Prioritize recent events if logs are extensive.
|
||||
* The \`inferredStatus\` should reflect the most likely state *deduced purely from the log text provided*. Ensure it is one of the specified enum values.`;
|
||||
|
||||
const response = await this.ai.generateJson(
|
||||
[{ role: 'user', parts: [{ text: prompt }] }],
|
||||
const schema: SchemaUnion = {
|
||||
type: Type.OBJECT,
|
||||
properties: {
|
||||
summary: {
|
||||
type: Type.STRING,
|
||||
description:
|
||||
'Concise markdown summary (1-3 sentences) of log interpretation.',
|
||||
},
|
||||
inferredStatus: {
|
||||
type: Type.STRING,
|
||||
description:
|
||||
'Status inferred from logs: Running, SuccessReported, ErrorReported, Unknown',
|
||||
enum: ['Running', 'SuccessReported', 'ErrorReported', 'Unknown'],
|
||||
},
|
||||
},
|
||||
required: ['summary', 'inferredStatus'],
|
||||
};
|
||||
|
||||
try {
|
||||
const resultJson = await this.geminiClient.generateJson(
|
||||
[{ role: 'user', parts: [{ text: analysisPrompt }] }],
|
||||
schema,
|
||||
);
|
||||
|
||||
// --- Enhanced Validation ---
|
||||
if (typeof response !== 'object' || response === null) {
|
||||
throw new Error(
|
||||
`LLM returned non-object response: ${JSON.stringify(response)}`,
|
||||
);
|
||||
}
|
||||
if (
|
||||
typeof response.summary !== 'string' ||
|
||||
response.summary.trim() === ''
|
||||
) {
|
||||
// Ensure summary is a non-empty string
|
||||
console.warn(
|
||||
"LLM response validation warning: 'summary' field is missing, empty or not a string. Raw response:",
|
||||
response,
|
||||
);
|
||||
// Decide how to handle: throw error, or assign default? Let's throw for now.
|
||||
throw new Error(
|
||||
`LLM response missing or invalid 'summary'. Got: ${JSON.stringify(response.summary)}`,
|
||||
);
|
||||
}
|
||||
if (
|
||||
!['Running', 'SuccessReported', 'ErrorReported', 'Unknown'].includes(
|
||||
response.inferredStatus,
|
||||
)
|
||||
) {
|
||||
console.warn(
|
||||
`LLM response validation warning: 'inferredStatus' is invalid ('${response.inferredStatus}'). Raw response:`,
|
||||
response,
|
||||
);
|
||||
// Decide how to handle: throw error, or default to 'Unknown'? Let's throw.
|
||||
throw new Error(
|
||||
`LLM returned invalid 'inferredStatus': ${JSON.stringify(response.inferredStatus)}`,
|
||||
);
|
||||
}
|
||||
// Validate and construct the AnalysisResult object
|
||||
const summary =
|
||||
typeof resultJson?.summary === 'string'
|
||||
? resultJson.summary
|
||||
: '[Summary unavailable]';
|
||||
|
||||
return response as AnalysisResult; // Cast after validation
|
||||
// Define valid statuses using the AnalysisStatus type (ensure it's defined above)
|
||||
const validStatuses: Array<Exclude<AnalysisStatus, 'AnalysisFailed'>> = [
|
||||
'Running',
|
||||
'SuccessReported',
|
||||
'ErrorReported',
|
||||
'Unknown',
|
||||
];
|
||||
|
||||
// Cast the unknown value to string before checking with includes
|
||||
const statusString = resultJson?.inferredStatus as string;
|
||||
const inferredStatus = validStatuses.includes(
|
||||
statusString as Exclude<AnalysisStatus, 'AnalysisFailed'>,
|
||||
)
|
||||
? (statusString as Exclude<AnalysisStatus, 'AnalysisFailed'>)
|
||||
: 'Unknown';
|
||||
|
||||
// Explicitly construct the object matching AnalysisResult type
|
||||
const analysisResult: AnalysisResult = { summary, inferredStatus };
|
||||
return analysisResult;
|
||||
} catch (error: unknown) {
|
||||
console.error(
|
||||
`LLM analysis call failed for command "${command}":`,
|
||||
error,
|
||||
);
|
||||
// Ensure the error message passed back is helpful
|
||||
return {
|
||||
error: `LLM analysis call encountered an error: ${getErrorMessage(error)}`,
|
||||
inferredStatus: 'AnalysisFailed',
|
||||
console.error(`LLM Analysis Request Failed for PID ${pid}:`, error);
|
||||
// Return the AnalysisFailure type
|
||||
const analysisFailure: AnalysisFailure = {
|
||||
error: `[Analysis failed: ${getErrorMessage(error)}]`,
|
||||
inferredStatus: 'AnalysisFailed', // This matches the AnalysisStatus type
|
||||
};
|
||||
return analysisFailure;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
export function isNodeError(error: unknown): error is NodeJS.ErrnoException {
|
||||
return error instanceof Error && 'code' in error;
|
||||
}
|
||||
|
||||
export function getErrorMessage(error: unknown): string {
|
||||
if (error instanceof Error) {
|
||||
return error.message;
|
||||
} else {
|
||||
// Attempt to convert the non-Error value to a string for logging
|
||||
try {
|
||||
const errorMessage = String(error);
|
||||
return errorMessage;
|
||||
} catch {
|
||||
// If String() itself fails (highly unlikely)
|
||||
return 'Failed to get error details';
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,389 +0,0 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import * as fs from 'fs/promises';
|
||||
import * as path from 'path';
|
||||
import { getErrorMessage, isNodeError } from './errors.js';
|
||||
|
||||
const MAX_ITEMS = 200;
|
||||
const TRUNCATION_INDICATOR = '...';
|
||||
const DEFAULT_IGNORED_FOLDERS = new Set(['node_modules', '.git', 'dist']);
|
||||
|
||||
// --- Interfaces ---
|
||||
|
||||
/** Options for customizing folder structure retrieval. */
|
||||
interface FolderStructureOptions {
|
||||
/** Maximum number of files and folders combined to display. Defaults to 200. */
|
||||
maxItems?: number;
|
||||
/** Set of folder names to ignore completely. Case-sensitive. */
|
||||
ignoredFolders?: Set<string>;
|
||||
/** Optional regex to filter included files by name. */
|
||||
fileIncludePattern?: RegExp;
|
||||
}
|
||||
|
||||
// Define a type for the merged options where fileIncludePattern remains optional
|
||||
type MergedFolderStructureOptions = Required<
|
||||
Omit<FolderStructureOptions, 'fileIncludePattern'>
|
||||
> & {
|
||||
fileIncludePattern?: RegExp;
|
||||
};
|
||||
|
||||
/** Represents the full, unfiltered information about a folder and its contents. */
|
||||
interface FullFolderInfo {
|
||||
name: string;
|
||||
path: string;
|
||||
files: string[];
|
||||
subFolders: FullFolderInfo[];
|
||||
totalChildren: number; // Total files + subfolders recursively
|
||||
totalFiles: number; // Total files recursively
|
||||
isIgnored?: boolean; // Flag to easily identify ignored folders later
|
||||
}
|
||||
|
||||
/** Represents the potentially truncated structure used for display. */
|
||||
interface ReducedFolderNode {
|
||||
name: string; // Folder name
|
||||
isRoot?: boolean;
|
||||
files: string[]; // File names, might end with '...'
|
||||
subFolders: ReducedFolderNode[]; // Subfolders, might be truncated
|
||||
hasMoreFiles?: boolean; // Indicates if files were truncated for this specific folder
|
||||
hasMoreSubfolders?: boolean; // Indicates if subfolders were truncated for this specific folder
|
||||
}
|
||||
|
||||
// --- Helper Functions ---
|
||||
|
||||
/**
|
||||
* Recursively reads the full directory structure without truncation.
|
||||
* Ignored folders are included but not recursed into.
|
||||
* @param folderPath The absolute path to the folder.
|
||||
* @param options Configuration options.
|
||||
* @returns A promise resolving to the FullFolderInfo or null if access denied/not found.
|
||||
*/
|
||||
async function readFullStructure(
|
||||
folderPath: string,
|
||||
options: MergedFolderStructureOptions,
|
||||
): Promise<FullFolderInfo | null> {
|
||||
const name = path.basename(folderPath);
|
||||
// Initialize with isIgnored: false
|
||||
const folderInfo: Omit<FullFolderInfo, 'totalChildren' | 'totalFiles'> = {
|
||||
name,
|
||||
path: folderPath,
|
||||
files: [],
|
||||
subFolders: [],
|
||||
isIgnored: false,
|
||||
};
|
||||
|
||||
let totalChildrenCount = 0;
|
||||
let totalFileCount = 0;
|
||||
|
||||
try {
|
||||
const entries = await fs.readdir(folderPath, { withFileTypes: true });
|
||||
|
||||
// Process directories first
|
||||
for (const entry of entries) {
|
||||
if (entry.isDirectory()) {
|
||||
const subFolderName = entry.name;
|
||||
const subFolderPath = path.join(folderPath, subFolderName);
|
||||
|
||||
// Check if the folder should be ignored
|
||||
if (options.ignoredFolders.has(subFolderName)) {
|
||||
// Add ignored folder node but don't recurse
|
||||
const ignoredFolderInfo: FullFolderInfo = {
|
||||
name: subFolderName,
|
||||
path: subFolderPath,
|
||||
files: [],
|
||||
subFolders: [],
|
||||
totalChildren: 0, // No children explored
|
||||
totalFiles: 0, // No files explored
|
||||
isIgnored: true, // Mark as ignored
|
||||
};
|
||||
folderInfo.subFolders.push(ignoredFolderInfo);
|
||||
// Skip recursion for this folder
|
||||
continue;
|
||||
}
|
||||
|
||||
// If not ignored, recurse as before
|
||||
const subFolderInfo = await readFullStructure(subFolderPath, options);
|
||||
// Add non-empty folders OR explicitly ignored folders
|
||||
if (
|
||||
subFolderInfo &&
|
||||
(subFolderInfo.totalChildren > 0 ||
|
||||
subFolderInfo.files.length > 0 ||
|
||||
subFolderInfo.isIgnored)
|
||||
) {
|
||||
folderInfo.subFolders.push(subFolderInfo);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Then process files (only if the current folder itself isn't marked as ignored)
|
||||
for (const entry of entries) {
|
||||
if (entry.isFile()) {
|
||||
const fileName = entry.name;
|
||||
// Include if no pattern or if pattern matches
|
||||
if (
|
||||
!options.fileIncludePattern ||
|
||||
options.fileIncludePattern.test(fileName)
|
||||
) {
|
||||
folderInfo.files.push(fileName);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate totals *after* processing children
|
||||
// Ignored folders contribute 0 to counts here because we didn't look inside.
|
||||
totalFileCount =
|
||||
folderInfo.files.length +
|
||||
folderInfo.subFolders.reduce((sum, sf) => sum + sf.totalFiles, 0);
|
||||
// Count the ignored folder itself as one child item in the parent's count.
|
||||
totalChildrenCount =
|
||||
folderInfo.files.length +
|
||||
folderInfo.subFolders.length +
|
||||
folderInfo.subFolders.reduce((sum, sf) => sum + sf.totalChildren, 0);
|
||||
} catch (error: unknown) {
|
||||
if (
|
||||
isNodeError(error) &&
|
||||
(error.code === 'EACCES' || error.code === 'ENOENT')
|
||||
) {
|
||||
console.warn(
|
||||
`Warning: Could not read directory ${folderPath}: ${error.message}`,
|
||||
);
|
||||
return null;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
|
||||
return {
|
||||
...(folderInfo as FullFolderInfo), // Cast needed after conditional assignment check
|
||||
totalChildren: totalChildrenCount,
|
||||
totalFiles: totalFileCount,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Reduces the full folder structure based on the maxItems limit using BFS.
|
||||
* Handles explicitly ignored folders by showing them with a truncation indicator.
|
||||
* @param fullInfo The complete folder structure info.
|
||||
* @param maxItems The maximum number of items (files + folders) to include.
|
||||
* @param ignoredFolders The set of folder names that were ignored during the read phase.
|
||||
* @returns The root node of the reduced structure.
|
||||
*/
|
||||
function reduceStructure(
|
||||
fullInfo: FullFolderInfo,
|
||||
maxItems: number,
|
||||
): ReducedFolderNode {
|
||||
const rootReducedNode: ReducedFolderNode = {
|
||||
name: fullInfo.name,
|
||||
files: [],
|
||||
subFolders: [],
|
||||
isRoot: true,
|
||||
};
|
||||
const queue: Array<{
|
||||
original: FullFolderInfo;
|
||||
reduced: ReducedFolderNode;
|
||||
}> = [];
|
||||
|
||||
// Don't count the root itself towards the limit initially
|
||||
queue.push({ original: fullInfo, reduced: rootReducedNode });
|
||||
let itemCount = 0; // Count folders + files added to the reduced structure
|
||||
|
||||
while (queue.length > 0) {
|
||||
const { original: originalFolder, reduced: reducedFolder } = queue.shift()!;
|
||||
|
||||
// If the folder being processed was itself marked as ignored (shouldn't happen for root)
|
||||
if (originalFolder.isIgnored) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Process Files
|
||||
let fileLimitReached = false;
|
||||
for (const file of originalFolder.files) {
|
||||
// Check limit *before* adding the file
|
||||
if (itemCount >= maxItems) {
|
||||
if (!fileLimitReached) {
|
||||
reducedFolder.files.push(TRUNCATION_INDICATOR);
|
||||
reducedFolder.hasMoreFiles = true;
|
||||
fileLimitReached = true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
reducedFolder.files.push(file);
|
||||
itemCount++;
|
||||
}
|
||||
|
||||
// Process Subfolders
|
||||
let subfolderLimitReached = false;
|
||||
for (const subFolder of originalFolder.subFolders) {
|
||||
// Count the folder itself towards the limit
|
||||
itemCount++;
|
||||
if (itemCount > maxItems) {
|
||||
if (!subfolderLimitReached) {
|
||||
// Add a placeholder node ONLY if we haven't already added one
|
||||
const truncatedSubfolderNode: ReducedFolderNode = {
|
||||
name: subFolder.name,
|
||||
files: [TRUNCATION_INDICATOR], // Generic truncation
|
||||
subFolders: [],
|
||||
hasMoreFiles: true,
|
||||
};
|
||||
reducedFolder.subFolders.push(truncatedSubfolderNode);
|
||||
reducedFolder.hasMoreSubfolders = true;
|
||||
subfolderLimitReached = true;
|
||||
}
|
||||
continue; // Stop processing further subfolders for this parent
|
||||
}
|
||||
|
||||
// Handle explicitly ignored folders identified during the read phase
|
||||
if (subFolder.isIgnored) {
|
||||
const ignoredReducedNode: ReducedFolderNode = {
|
||||
name: subFolder.name,
|
||||
files: [TRUNCATION_INDICATOR], // Indicate contents ignored/truncated
|
||||
subFolders: [],
|
||||
hasMoreFiles: true, // Mark as truncated
|
||||
};
|
||||
reducedFolder.subFolders.push(ignoredReducedNode);
|
||||
// DO NOT add the ignored folder to the queue for further processing
|
||||
} else {
|
||||
// If not ignored and within limit, create the reduced node and add to queue
|
||||
const reducedSubFolder: ReducedFolderNode = {
|
||||
name: subFolder.name,
|
||||
files: [],
|
||||
subFolders: [],
|
||||
};
|
||||
reducedFolder.subFolders.push(reducedSubFolder);
|
||||
queue.push({ original: subFolder, reduced: reducedSubFolder });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return rootReducedNode;
|
||||
}
|
||||
|
||||
/** Calculates the total number of items present in the reduced structure. */
|
||||
function countReducedItems(node: ReducedFolderNode): number {
|
||||
let count = 0;
|
||||
// Count files, treating '...' as one item if present
|
||||
count += node.files.length;
|
||||
|
||||
// Count subfolders and recursively count their contents
|
||||
count += node.subFolders.length;
|
||||
for (const sub of node.subFolders) {
|
||||
// Check if it's a placeholder ignored/truncated node
|
||||
const isTruncatedPlaceholder =
|
||||
sub.files.length === 1 &&
|
||||
sub.files[0] === TRUNCATION_INDICATOR &&
|
||||
sub.subFolders.length === 0;
|
||||
|
||||
if (!isTruncatedPlaceholder) {
|
||||
count += countReducedItems(sub);
|
||||
}
|
||||
// Don't add count for items *inside* the placeholder node itself.
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats the reduced folder structure into a tree-like string.
|
||||
* (No changes needed in this function)
|
||||
* @param node The current node in the reduced structure.
|
||||
* @param indent The current indentation string.
|
||||
* @param isLast Sibling indicator.
|
||||
* @param builder Array to build the string lines.
|
||||
*/
|
||||
function formatReducedStructure(
|
||||
node: ReducedFolderNode,
|
||||
indent: string,
|
||||
isLast: boolean,
|
||||
builder: string[],
|
||||
): void {
|
||||
const connector = isLast ? '└───' : '├───';
|
||||
const linePrefix = indent + connector;
|
||||
|
||||
// Don't print the root node's name directly, only its contents
|
||||
if (!node.isRoot) {
|
||||
builder.push(`${linePrefix}${node.name}/`);
|
||||
}
|
||||
|
||||
const childIndent = indent + (isLast || node.isRoot ? ' ' : '│ '); // Use " " if last, "│" otherwise
|
||||
|
||||
// Render files
|
||||
const fileCount = node.files.length;
|
||||
for (let i = 0; i < fileCount; i++) {
|
||||
const isLastFile = i === fileCount - 1 && node.subFolders.length === 0;
|
||||
const fileConnector = isLastFile ? '└───' : '├───';
|
||||
builder.push(`${childIndent}${fileConnector}${node.files[i]}`);
|
||||
}
|
||||
|
||||
// Render subfolders
|
||||
const subFolderCount = node.subFolders.length;
|
||||
for (let i = 0; i < subFolderCount; i++) {
|
||||
const isLastSub = i === subFolderCount - 1;
|
||||
formatReducedStructure(node.subFolders[i], childIndent, isLastSub, builder);
|
||||
}
|
||||
}
|
||||
|
||||
// --- Main Exported Function ---
|
||||
|
||||
/**
|
||||
* Generates a string representation of a directory's structure,
|
||||
* limiting the number of items displayed. Ignored folders are shown
|
||||
* followed by '...' instead of their contents.
|
||||
*
|
||||
* @param directory The absolute or relative path to the directory.
|
||||
* @param options Optional configuration settings.
|
||||
* @returns A promise resolving to the formatted folder structure string.
|
||||
*/
|
||||
export async function getFolderStructure(
|
||||
directory: string,
|
||||
options?: FolderStructureOptions,
|
||||
): Promise<string> {
|
||||
const resolvedPath = path.resolve(directory);
|
||||
const mergedOptions: MergedFolderStructureOptions = {
|
||||
maxItems: options?.maxItems ?? MAX_ITEMS,
|
||||
ignoredFolders: options?.ignoredFolders ?? DEFAULT_IGNORED_FOLDERS,
|
||||
fileIncludePattern: options?.fileIncludePattern,
|
||||
};
|
||||
|
||||
try {
|
||||
// 1. Read the full structure (includes ignored folders marked as such)
|
||||
const fullInfo = await readFullStructure(resolvedPath, mergedOptions);
|
||||
|
||||
if (!fullInfo) {
|
||||
return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
|
||||
}
|
||||
|
||||
// 2. Reduce the structure (handles ignored folders specifically)
|
||||
const reducedRoot = reduceStructure(fullInfo, mergedOptions.maxItems);
|
||||
|
||||
// 3. Count items in the *reduced* structure for the summary
|
||||
const rootNodeItselfCount = 0; // Don't count the root node in the items summary
|
||||
const reducedItemCount =
|
||||
countReducedItems(reducedRoot) - rootNodeItselfCount;
|
||||
|
||||
// 4. Format the reduced structure into a string
|
||||
const structureLines: string[] = [];
|
||||
formatReducedStructure(reducedRoot, '', true, structureLines);
|
||||
|
||||
// 5. Build the final output string
|
||||
const displayPath = resolvedPath.replace(/\\/g, '/');
|
||||
const totalOriginalChildren = fullInfo.totalChildren;
|
||||
|
||||
let disclaimer = '';
|
||||
// Check if any truncation happened OR if ignored folders were present
|
||||
if (
|
||||
reducedItemCount < totalOriginalChildren ||
|
||||
fullInfo.subFolders.some((sf) => sf.isIgnored)
|
||||
) {
|
||||
disclaimer = `Folders or files indicated with ${TRUNCATION_INDICATOR} contain more items not shown or were ignored.`;
|
||||
}
|
||||
|
||||
const summary =
|
||||
`Showing ${reducedItemCount} of ${totalOriginalChildren} items (files + folders). ${disclaimer}`.trim();
|
||||
|
||||
return `${summary}\n\n${displayPath}/\n${structureLines.join('\n')}`;
|
||||
} catch (error: unknown) {
|
||||
console.error(`Error getting folder structure for ${resolvedPath}:`, error);
|
||||
return `Error processing directory "${resolvedPath}": ${getErrorMessage(error)}`;
|
||||
}
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import path from 'node:path'; // Import the 'path' module
|
||||
|
||||
/**
|
||||
* Shortens a path string if it exceeds maxLen, prioritizing the start and end segments.
|
||||
* Example: /path/to/a/very/long/file.txt -> /path/.../long/file.txt
|
||||
*/
|
||||
export function shortenPath(filePath: string, maxLen: number = 35): string {
|
||||
if (filePath.length <= maxLen) {
|
||||
return filePath;
|
||||
}
|
||||
|
||||
const parsedPath = path.parse(filePath);
|
||||
const root = parsedPath.root;
|
||||
const separator = path.sep;
|
||||
|
||||
// Get segments of the path *after* the root
|
||||
const relativePath = filePath.substring(root.length);
|
||||
const segments = relativePath.split(separator).filter((s) => s !== ''); // Filter out empty segments
|
||||
|
||||
// Handle cases with no segments after root (e.g., "/", "C:\") or only one segment
|
||||
if (segments.length <= 1) {
|
||||
// Fallback to simple start/end truncation for very short paths or single segments
|
||||
const keepLen = Math.floor((maxLen - 3) / 2);
|
||||
// Ensure keepLen is not negative if maxLen is very small
|
||||
if (keepLen <= 0) {
|
||||
return filePath.substring(0, maxLen - 3) + '...';
|
||||
}
|
||||
const start = filePath.substring(0, keepLen);
|
||||
const end = filePath.substring(filePath.length - keepLen);
|
||||
return `${start}...${end}`;
|
||||
}
|
||||
|
||||
const firstDir = segments[0];
|
||||
const startComponent = root + firstDir;
|
||||
|
||||
const endPartSegments: string[] = [];
|
||||
// Base length: startComponent + separator + "..."
|
||||
let currentLength = startComponent.length + separator.length + 3;
|
||||
|
||||
// Iterate backwards through segments (excluding the first one)
|
||||
for (let i = segments.length - 1; i >= 1; i--) {
|
||||
const segment = segments[i];
|
||||
// Length needed if we add this segment: current + separator + segment
|
||||
const lengthWithSegment = currentLength + separator.length + segment.length;
|
||||
|
||||
if (lengthWithSegment <= maxLen) {
|
||||
endPartSegments.unshift(segment); // Add to the beginning of the end part
|
||||
currentLength = lengthWithSegment;
|
||||
} else {
|
||||
// Adding this segment would exceed maxLen
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Construct the final path
|
||||
let result = startComponent + separator + '...';
|
||||
if (endPartSegments.length > 0) {
|
||||
result += separator + endPartSegments.join(separator);
|
||||
}
|
||||
|
||||
// As a final check, if the result is somehow still too long (e.g., startComponent + ... is too long)
|
||||
// fallback to simple truncation of the original path
|
||||
if (result.length > maxLen) {
|
||||
const keepLen = Math.floor((maxLen - 3) / 2);
|
||||
if (keepLen <= 0) {
|
||||
return filePath.substring(0, maxLen - 3) + '...';
|
||||
}
|
||||
const start = filePath.substring(0, keepLen);
|
||||
const end = filePath.substring(filePath.length - keepLen);
|
||||
return `${start}...${end}`;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the relative path from a root directory to a target path.
|
||||
* Ensures both paths are resolved before calculating.
|
||||
* Returns '.' if the target path is the same as the root directory.
|
||||
*
|
||||
* @param targetPath The absolute or relative path to make relative.
|
||||
* @param rootDirectory The absolute path of the directory to make the target path relative to.
|
||||
* @returns The relative path from rootDirectory to targetPath.
|
||||
*/
|
||||
export function makeRelative(
|
||||
targetPath: string,
|
||||
rootDirectory: string,
|
||||
): string {
|
||||
const resolvedTargetPath = path.resolve(targetPath);
|
||||
const resolvedRootDirectory = path.resolve(rootDirectory);
|
||||
|
||||
const relativePath = path.relative(resolvedRootDirectory, resolvedTargetPath);
|
||||
|
||||
// If the paths are the same, path.relative returns '', return '.' instead
|
||||
return relativePath || '.';
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* Simple utility to validate objects against JSON Schemas
|
||||
* In a real implementation, you would use a library like Ajv
|
||||
*/
|
||||
export class SchemaValidator {
|
||||
/**
|
||||
* Validates data against a JSON schema
|
||||
* @param schema JSON Schema to validate against
|
||||
* @param data Data to validate
|
||||
* @returns True if valid, false otherwise
|
||||
*/
|
||||
static validate(schema: Record<string, unknown>, data: unknown): boolean {
|
||||
// This is a simplified implementation
|
||||
// In a real application, you would use a library like Ajv for proper validation
|
||||
|
||||
// Check for required fields
|
||||
if (schema.required && Array.isArray(schema.required)) {
|
||||
const required = schema.required as string[];
|
||||
const dataObj = data as Record<string, unknown>;
|
||||
|
||||
for (const field of required) {
|
||||
if (dataObj[field] === undefined) {
|
||||
console.error(`Missing required field: ${field}`);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check property types if properties are defined
|
||||
if (schema.properties && typeof schema.properties === 'object') {
|
||||
const properties = schema.properties as Record<string, { type?: string }>;
|
||||
const dataObj = data as Record<string, unknown>;
|
||||
|
||||
for (const [key, prop] of Object.entries(properties)) {
|
||||
if (dataObj[key] !== undefined && prop.type) {
|
||||
const expectedType = prop.type;
|
||||
const actualType = Array.isArray(dataObj[key])
|
||||
? 'array'
|
||||
: typeof dataObj[key];
|
||||
|
||||
if (expectedType !== actualType) {
|
||||
console.error(
|
||||
`Type mismatch for property "${key}": expected ${expectedType}, got ${actualType}`,
|
||||
);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user