@proletariat/cli 0.3.9 → 0.3.11

package/dist/commands/execution/stop.js

@@ -100,6 +100,7 @@ export default class ExecutionStop extends PMOCommand {
         let failed = 0;
         for (const execution of activeExecutions) {
             try {
+                // eslint-disable-next-line no-await-in-loop -- Sequential stop with user feedback
                 const success = await this.stopExecution(execution, flags.force || false);
                 if (success) {
                     executionStorage.updateStatus(execution.id, 'stopped');

package/dist/commands/init.js

@@ -161,10 +161,10 @@ export default class Init extends Command {
                 storageType: 'sqlite',
             },
         };
+        // Suppress console output in JSON mode
+        const originalLog = console.log;
+        console.log = () => { };
         try {
-            // Suppress console output in JSON mode
-            const originalLog = console.log;
-            console.log = () => { };
             // Initialize the HQ
             await initializeHQ(options);
             // Restore console.log
@@ -183,7 +183,7 @@ export default class Init extends Command {
         }
         catch (error) {
             // Restore console.log on error
-            console.log = console.log;
+            console.log = originalLog;
             this.outputJson({
                 success: false,
                 error: error instanceof Error ? error.message : 'Unknown error',

package/dist/commands/project/index.js

@@ -1,6 +1,6 @@
 import { Flags } from '@oclif/core';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
-import { shouldOutputJson, } from '../../lib/prompt-json.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
 export default class Project extends PMOCommand {
     static description = 'Interactive menu for project operations';
     static examples = [

package/dist/commands/project/spec.js

@@ -133,6 +133,7 @@ export default class ProjectSpec extends PMOCommand {
         let continueLoop = true;
         while (continueLoop) {
             // Refresh project specs each iteration
+            // eslint-disable-next-line no-await-in-loop -- Interactive user loop
             const currentSpecs = await this.storage.getSpecsForProject(projectId);
             const currentSpecIds = new Set(currentSpecs.map(s => s.id));
             this.log(styles.title(`\nSpecs for project "${project.name}" (${projectId})`));
@@ -144,6 +145,7 @@ export default class ProjectSpec extends PMOCommand {
                     this.log(`  ${styles.code(spec.id)} - ${spec.title} (${spec.status})`);
                 }
             }
+            // eslint-disable-next-line no-await-in-loop -- Interactive user prompt
             const { action } = await inquirer.prompt([{
                     type: 'list',
                     name: 'action',
@@ -161,12 +163,14 @@ export default class ProjectSpec extends PMOCommand {
             }
             if (action === 'add') {
                 // Get all specs not already associated
+                // eslint-disable-next-line no-await-in-loop -- User action handling
                 const allSpecs = await this.storage.listSpecs();
                 const availableSpecs = allSpecs.filter(s => !currentSpecIds.has(s.id));
                 if (availableSpecs.length === 0) {
                     this.log(styles.muted('\n  All specs are already associated with this project.'));
                     continue;
                 }
+                // eslint-disable-next-line no-await-in-loop -- User selection prompt
                 const { selected } = await inquirer.prompt([{
                         type: 'checkbox',
                         name: 'selected',
@@ -181,6 +185,7 @@ export default class ProjectSpec extends PMOCommand {
                     continue;
                 }
                 for (const specId of selected) {
+                    // eslint-disable-next-line no-await-in-loop -- Sequential updates with feedback
                     await this.storage.linkProjectToSpec(projectId, specId);
                     this.log(styles.success(`  Added ${specId}`));
                 }
@@ -191,6 +196,7 @@ export default class ProjectSpec extends PMOCommand {
                     this.log(styles.muted('\n  No specs to remove.'));
                     continue;
                 }
+                // eslint-disable-next-line no-await-in-loop -- User selection prompt
                 const { selected } = await inquirer.prompt([{
                         type: 'checkbox',
                         name: 'selected',
@@ -205,6 +211,7 @@ export default class ProjectSpec extends PMOCommand {
                     continue;
                 }
                 for (const specId of selected) {
+                    // eslint-disable-next-line no-await-in-loop -- Sequential updates with feedback
                     await this.storage.unlinkProjectFromSpec(projectId, specId);
                     this.log(styles.success(`  Removed ${specId}`));
                 }

package/dist/commands/repo/add.js

@@ -96,6 +96,7 @@ export default class Add extends PMOCommand {
         let successCount = 0;
         let failCount = 0;
         for (const repo of reposToAdd) {
+            // eslint-disable-next-line no-await-in-loop -- Sequential add with user feedback
             const result = await addRepository(hqPath, repo.path, repo.action);
             if (result.success) {
                 this.log(format.success(`Repository ${result.name} added`));

package/dist/commands/repo/remove.js

@@ -195,6 +195,7 @@ export default class Remove extends PMOCommand {
         let failCount = 0;
         for (const repoName of selectedRepos) {
             this.log(colors.textMuted(`Removing ${repoName}...`));
+            // eslint-disable-next-line no-await-in-loop -- Sequential remove with user feedback
             const result = await removeRepository(hqPath, repoName, keepFiles);
             if (result.success) {
                 this.log(format.success(`Removed ${repoName}`));

package/dist/commands/roadmap/add-project.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class RoadmapAddProject extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        roadmap: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        project: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        position: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/roadmap/add-project.js

@@ -0,0 +1,135 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class RoadmapAddProject extends PMOCommand {
+    static description = 'Add a project to a roadmap';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-roadmap my-project',
+        '<%= config.bin %> <%= command.id %> my-roadmap  # Interactive project selection',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection for both',
+    ];
+    static args = {
+        roadmap: Args.string({
+            description: 'Roadmap ID',
+            required: false,
+        }),
+        project: Args.string({
+            description: 'Project ID to add',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        position: Flags.integer({
+            char: 'p',
+            description: 'Position in the roadmap (0-indexed)',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(RoadmapAddProject);
+        const jsonMode = shouldOutputJson(flags);
+        // Select roadmap
+        let roadmapId = args.roadmap;
+        if (!roadmapId) {
+            const roadmaps = await this.storage.listRoadmaps();
+            if (roadmaps.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_ROADMAPS', 'No roadmaps found', createMetadata('roadmap add-project', flags));
+                    return;
+                }
+                this.error('No roadmaps found. Create one with: prlt roadmap create');
+            }
+            if (jsonMode) {
+                const choices = roadmaps.map(r => ({
+                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                    value: r.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'roadmap', 'Select roadmap:', choices), createMetadata('roadmap add-project', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select roadmap:',
+                    choices: roadmaps.map(r => ({
+                        name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                        value: r.id,
+                    })),
+                }]);
+            roadmapId = selected;
+        }
+        const roadmap = await this.storage.getRoadmap(roadmapId);
+        if (!roadmap) {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_FOUND', `Roadmap not found: ${roadmapId}`, createMetadata('roadmap add-project', flags));
+                return;
+            }
+            this.error(`Roadmap not found: ${roadmapId}`);
+        }
+        // Get projects already in roadmap
+        const existingProjects = await this.storage.listRoadmapProjects(roadmapId);
+        const existingProjectIds = new Set(existingProjects.map(p => p.id));
+        // Get all projects and filter out ones already in roadmap
+        const allProjects = await this.storage.listProjects({ isArchived: false });
+        const availableProjects = allProjects.filter(p => !existingProjectIds.has(p.id));
+        if (availableProjects.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_AVAILABLE_PROJECTS', 'All projects are already in this roadmap', createMetadata('roadmap add-project', flags));
+                return;
+            }
+            this.error('All projects are already in this roadmap');
+        }
+        // Select project
+        let projectId = args.project;
+        if (!projectId) {
+            if (jsonMode) {
+                const choices = availableProjects.map(p => ({
+                    name: p.name,
+                    value: p.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'project', 'Select project to add:', choices), createMetadata('roadmap add-project', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select project to add:',
+                    choices: availableProjects.map(p => ({
+                        name: p.name,
+                        value: p.id,
+                    })),
+                }]);
+            projectId = selected;
+        }
+        // Verify project exists and isn't already in roadmap
+        const project = await this.storage.getProject(projectId);
+        if (!project) {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_FOUND', `Project not found: ${projectId}`, createMetadata('roadmap add-project', flags));
+                return;
+            }
+            this.error(`Project not found: ${projectId}`);
+        }
+        if (existingProjectIds.has(projectId)) {
+            if (jsonMode) {
+                outputErrorAsJson('ALREADY_IN_ROADMAP', `Project "${project.name}" is already in this roadmap`, createMetadata('roadmap add-project', flags));
+                return;
+            }
+            this.error(`Project "${project.name}" is already in this roadmap`);
+        }
+        // Add project to roadmap
+        await this.storage.addProjectToRoadmap(roadmapId, projectId, flags.position);
+        const projects = await this.storage.listRoadmapProjects(roadmapId);
+        const position = projects.findIndex(p => p.id === projectId) + 1;
+        this.log(styles.success(`Added "${project.name}" to "${roadmap.name}" at position ${position}`));
+    }
+}

package/dist/commands/roadmap/create.d.ts

@@ -0,0 +1,22 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class RoadmapCreate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        default: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private promptRoadmapData;
+}

package/dist/commands/roadmap/create.js

@@ -0,0 +1,156 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { slugify } from '../../lib/pmo/utils.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class RoadmapCreate extends PMOCommand {
+    static description = 'Create a new roadmap';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Public Roadmap"',
+        '<%= config.bin %> <%= command.id %> --name "Internal Roadmap" --description "Full project list"',
+        '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Roadmap name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'Roadmap name',
+        }),
+        id: Flags.string({
+            description: 'Custom roadmap ID (auto-generated from name if not provided)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Roadmap description',
+        }),
+        default: Flags.boolean({
+            description: 'Set as the default roadmap',
+            default: false,
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(RoadmapCreate);
+        const jsonMode = shouldOutputJson(flags);
+        let roadmapData;
+        if (flags.interactive || (!args.name && !flags.name)) {
+            const fields = [
+                { type: 'input', name: 'name', message: 'Roadmap name:', default: flags.name },
+                { type: 'input', name: 'id', message: 'Roadmap ID (leave blank to auto-generate):' },
+                { type: 'input', name: 'description', message: 'Description (optional):', default: flags.description },
+                {
+                    type: 'list',
+                    name: 'isDefault',
+                    message: 'Set as default roadmap?',
+                    choices: [
+                        { name: 'No', value: 'false' },
+                        { name: 'Yes', value: 'true' },
+                    ],
+                    default: flags.default ? 'true' : 'false',
+                },
+            ];
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('roadmap create', flags));
+                return;
+            }
+            roadmapData = await this.promptRoadmapData(fields);
+        }
+        else {
+            roadmapData = {
+                name: args.name || flags.name,
+                id: flags.id,
+                description: flags.description,
+                isDefault: flags.default,
+            };
+        }
+        const roadmapId = roadmapData.id || `roadmap-${slugify(roadmapData.name)}`;
+        // Check if roadmap already exists
+        const existing = await this.storage.getRoadmap(roadmapId);
+        if (existing) {
+            this.error(`Roadmap "${roadmapId}" already exists.`);
+        }
+        // Create roadmap in database
+        const roadmap = await this.storage.createRoadmap({
+            id: roadmapId,
+            name: roadmapData.name,
+            description: roadmapData.description,
+            isDefault: roadmapData.isDefault,
+        });
+        this.log(styles.success(`\nCreated roadmap "${styles.emphasis(roadmap.name)}"`));
+        this.log(styles.muted(`  ID: ${roadmap.id}`));
+        if (roadmap.description) {
+            this.log(styles.muted(`  Description: ${roadmap.description}`));
+        }
+        if (roadmap.isDefault) {
+            this.log(styles.muted(`  Default: Yes`));
+        }
+        // Prompt to add projects
+        const projects = await this.storage.listProjects({ isArchived: false });
+        if (projects.length > 0) {
+            this.log('');
+            const { addProjects } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'addProjects',
+                    message: 'Add projects to this roadmap now?',
+                    choices: [
+                        { name: 'Yes', value: true },
+                        { name: 'No, I\'ll add them later', value: false },
+                    ],
+                }]);
+            if (addProjects) {
+                const { selectedProjects } = await inquirer.prompt([{
+                        type: 'checkbox',
+                        name: 'selectedProjects',
+                        message: 'Select projects to include:',
+                        choices: projects.map(p => ({ name: p.name, value: p.id })),
+                    }]);
+                for (const projectId of selectedProjects) {
+                    // eslint-disable-next-line no-await-in-loop -- Sequential updates
+                    await this.storage.addProjectToRoadmap(roadmap.id, projectId);
+                }
+                if (selectedProjects.length > 0) {
+                    this.log(styles.success(`Added ${selectedProjects.length} project(s) to roadmap`));
+                }
+            }
+        }
+        this.log(styles.muted(`\nNext steps:`));
+        this.log(styles.muted(`  prlt roadmap view ${roadmap.id}`));
+        this.log(styles.muted(`  prlt roadmap add-project ${roadmap.id}`));
+        this.log(styles.muted(`  prlt roadmap generate ${roadmap.id}`));
+    }
+    async promptRoadmapData(fields) {
+        const answers = await inquirer.prompt(fields.map(field => ({
+            ...field,
+            validate: field.name === 'name'
+                ? ((input) => input.length > 0 || 'Name is required')
+                : undefined,
+            default: field.name === 'id'
+                ? ((answers) => `roadmap-${slugify(answers.name)}`)
+                : field.default,
+        })));
+        return {
+            name: answers.name,
+            id: answers.id || undefined,
+            description: answers.description || undefined,
+            isDefault: answers.isDefault === true || answers.isDefault === 'true',
+        };
+    }
+}

package/dist/commands/roadmap/delete.d.ts

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class RoadmapDelete extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/roadmap/delete.js

@@ -0,0 +1,104 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class RoadmapDelete extends PMOCommand {
+    static description = 'Delete a roadmap';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-roadmap',
+        '<%= config.bin %> <%= command.id %> my-roadmap --force',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Roadmap ID to delete',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(RoadmapDelete);
+        const jsonMode = shouldOutputJson(flags);
+        let roadmapId = args.id;
+        if (!roadmapId) {
+            const roadmaps = await this.storage.listRoadmaps();
+            if (roadmaps.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_ROADMAPS', 'No roadmaps found', createMetadata('roadmap delete', flags));
+                    return;
+                }
+                this.error('No roadmaps found.');
+            }
+            if (jsonMode) {
+                const choices = roadmaps.map(r => ({
+                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                    value: r.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select roadmap to delete:', choices), createMetadata('roadmap delete', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select roadmap to delete:',
+                    choices: roadmaps.map(r => ({
+                        name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                        value: r.id,
+                    })),
+                }]);
+            roadmapId = selected;
+        }
+        const roadmap = await this.storage.getRoadmap(roadmapId);
+        if (!roadmap) {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_FOUND', `Roadmap not found: ${roadmapId}`, createMetadata('roadmap delete', flags));
+                return;
+            }
+            this.error(`Roadmap not found: ${roadmapId}`);
+        }
+        // Get project count for context
+        const projects = await this.storage.listRoadmapProjects(roadmapId);
+        // Confirm deletion
+        if (!flags.force) {
+            const message = `Delete roadmap "${roadmap.name}"${projects.length > 0 ? ` (contains ${projects.length} project reference${projects.length > 1 ? 's' : ''})` : ''}?`;
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No, cancel', value: 'false' },
+                    { name: 'Yes, delete', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', message, confirmChoices), createMetadata('roadmap delete', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message,
+                    choices: [
+                        { name: 'No, cancel', value: false },
+                        { name: 'Yes, delete', value: true },
+                    ],
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        await this.storage.deleteRoadmap(roadmapId);
+        this.log(styles.success(`Deleted roadmap "${roadmap.name}"`));
+    }
+}

package/dist/commands/roadmap/generate.d.ts

@@ -0,0 +1,22 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class RoadmapGenerate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private generateRoadmap;
+    private getPriorityLabel;
+    private cleanForTable;
+    private truncateDescription;
+}