@taskset/cli 6.0.0 → 6.1.0

package/src/cli.ts

@@ -2,9 +2,11 @@ import { readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { parseArgs } from 'node:util'
 import {
+	ConcernClassSchema,
 	DocumentIdSchema,
 	DocumentStatusSchema,
 	DocumentTimestampSchema,
+	LessonSeveritySchema,
 	TaskIdSchema,
 	TaskPrioritySchema,
 	TaskRiskSchema,
@@ -31,6 +33,7 @@ import {
 	discoverRepository,
 	executeDocumentBatch,
 	generateViews,
+	getProgramRollup,
 	importDocument,
 	initializeRepository,
 	listDocuments,
@@ -73,8 +76,9 @@ const USAGE = `Usage:
   taskset task status <task-id> <status> [--json] [--cwd <path>]
   taskset task delete <task-id> [--remove-dependencies] [--json] [--cwd <path>]
   taskset task migrate-ids [--json] [--cwd <path>]
+  taskset task program <parent-id> [--json] [--cwd <path>]
   taskset sync [--concurrency <count>] [--json] [--cwd <path>]
-  taskset document create <story|flow|decision|adr|dr|research|runbook> --title <title> [metadata options]
+  taskset document create <story|flow|decision|adr|dr|research|runbook|lesson|antipattern|concern|audit> --title <title> [metadata options]
   taskset document import <markdown-path> [--type <type>] [--move]
   taskset document batch <manifest.json> [--concurrency <count>] [--json]
   taskset document list [type] [query options]
@@ -87,10 +91,12 @@ Metadata options:
   --status --priority --order --owner --team --estimate --effort --risk --due-date
   --label --assignee --reviewer --depends-on --related --duplicate
   --parent --file --directory --project --body
+  Lesson/concern options: --severity --related-skill --pack --class --cadence
   Repeat array options. Task and document updates clear arrays with --clear-dependencies,
   --clear-labels, --clear-assignees, --clear-reviewers, --clear-related,
-  --clear-files, --clear-directories, or --clear-projects. Clear scalar
-  relationships with --clear-parent or --clear-owner.
+  --clear-files, --clear-directories, --clear-projects, --clear-related-skills,
+  or --clear-packs. Clear scalar relationships with --clear-parent, --clear-owner,
+  --clear-severity, --clear-class, or --clear-cadence.
 
 List query options:
   --status --priority --label --owner --assignee --reviewer --team --risk
@@ -178,6 +184,11 @@ const DocumentInputSchema = z.strictObject({
 	parent: TaskIdSchema.optional(),
 	directories: StringListSchema.optional(),
 	projects: StringListSchema.optional(),
+	severity: LessonSeveritySchema.optional(),
+	relatedSkills: StringListSchema.optional(),
+	packs: StringListSchema.optional(),
+	class: ConcernClassSchema.optional(),
+	cadence: TrimmedStringSchema.optional(),
 	body: z.string().optional(),
 })
 const DocumentUpdateSchema = z
@@ -202,6 +213,11 @@ const DocumentUpdateSchema = z
 		parent: TaskIdSchema.nullable().optional(),
 		directories: StringListSchema.optional(),
 		projects: StringListSchema.optional(),
+		severity: LessonSeveritySchema.nullable().optional(),
+		relatedSkills: StringListSchema.optional(),
+		packs: StringListSchema.optional(),
+		class: ConcernClassSchema.nullable().optional(),
+		cadence: TrimmedStringSchema.nullable().optional(),
 		body: z.string().optional(),
 	})
 	.refine((input) => Object.keys(input).length > 0, 'Document update requires at least one field')
@@ -258,6 +274,15 @@ const UPDATE_CLEAR_PAIRS = [
 	['project', 'clear-projects'],
 ] as const
 
+const DOCUMENT_UPDATE_CLEAR_PAIRS = [
+	...UPDATE_CLEAR_PAIRS,
+	['severity', 'clear-severity'],
+	['related-skill', 'clear-related-skills'],
+	['pack', 'clear-packs'],
+	['class', 'clear-class'],
+	['cadence', 'clear-cadence'],
+] as const
+
 const DocumentCreateValuesSchema = z.strictObject({
 	title: TrimmedStringSchema,
 	status: DocumentStatusSchema.optional(),
@@ -279,6 +304,11 @@ const DocumentCreateValuesSchema = z.strictObject({
 	parent: TaskIdSchema.optional(),
 	directory: StringListSchema.optional(),
 	project: StringListSchema.optional(),
+	severity: LessonSeveritySchema.optional(),
+	'related-skill': StringListSchema.optional(),
+	pack: StringListSchema.optional(),
+	class: ConcernClassSchema.optional(),
+	cadence: TrimmedStringSchema.optional(),
 	body: z.string().optional(),
 	cwd: CwdSchema,
 	json: JsonSchema,
@@ -306,6 +336,11 @@ const DocumentUpdateValuesSchema = z
 		parent: TaskIdSchema.optional(),
 		directory: StringListSchema.optional(),
 		project: StringListSchema.optional(),
+		severity: LessonSeveritySchema.optional(),
+		'related-skill': StringListSchema.optional(),
+		pack: StringListSchema.optional(),
+		class: ConcernClassSchema.optional(),
+		cadence: TrimmedStringSchema.optional(),
 		body: z.string().optional(),
 		type: TrimmedStringSchema.optional(),
 		'clear-priority': z.boolean().optional(),
@@ -326,11 +361,16 @@ const DocumentUpdateValuesSchema = z
 		'clear-parent': z.boolean().optional(),
 		'clear-directories': z.boolean().optional(),
 		'clear-projects': z.boolean().optional(),
+		'clear-severity': z.boolean().optional(),
+		'clear-related-skills': z.boolean().optional(),
+		'clear-packs': z.boolean().optional(),
+		'clear-class': z.boolean().optional(),
+		'clear-cadence': z.boolean().optional(),
 		cwd: CwdSchema,
 		json: JsonSchema,
 	})
 	.superRefine((values, context) => {
-		for (const [valueKey, clearKey] of UPDATE_CLEAR_PAIRS) {
+		for (const [valueKey, clearKey] of DOCUMENT_UPDATE_CLEAR_PAIRS) {
 			if (values[valueKey] !== undefined && values[clearKey]) {
 				context.addIssue({
 					code: 'custom',
@@ -362,6 +402,8 @@ const DocumentListValuesSchema = z.strictObject({
 	team: StringListSchema.optional(),
 	risk: z.array(TaskRiskSchema).optional(),
 	project: StringListSchema.optional(),
+	class: z.array(ConcernClassSchema).optional(),
+	severity: z.array(LessonSeveritySchema).optional(),
 	'depends-on': TaskIdSchema.optional(),
 	related: TaskIdSchema.optional(),
 	duplicate: TaskIdSchema.optional(),
@@ -537,6 +579,15 @@ const metadataOptionDefinitions = {
 	project: { type: 'string', multiple: true },
 } as const
 
+const documentMetadataOptionDefinitions = {
+	...metadataOptionDefinitions,
+	severity: { type: 'string' },
+	'related-skill': { type: 'string', multiple: true },
+	pack: { type: 'string', multiple: true },
+	class: { type: 'string' },
+	cadence: { type: 'string' },
+} as const
+
 const commonOptionDefinitions = {
 	cwd: { type: 'string' },
 	json: { type: 'boolean' },
@@ -757,101 +808,59 @@ function documentUpdateInputFromValues(
 	repository: Awaited<ReturnType<typeof discoverRepository>>,
 	values: z.infer<typeof DocumentUpdateValuesSchema>,
 ): UpdateDocumentInput {
-	return {
-		...(values.title !== undefined ? { title: values.title } : {}),
-		...(values.status !== undefined ? { status: values.status } : {}),
-		...(values['clear-priority']
-			? { priority: null }
-			: values.priority !== undefined
-				? { priority: values.priority }
-				: {}),
-		...(values['clear-order']
-			? { order: null }
-			: values.order !== undefined
-				? { order: values.order }
-				: {}),
-		...(values['clear-labels']
-			? { labels: [] }
-			: values.label !== undefined
-				? { labels: values.label }
-				: {}),
-		...(values['clear-dependencies']
-			? { dependsOn: [] }
-			: values['depends-on'] !== undefined
-				? { dependsOn: values['depends-on'] }
-				: {}),
-		...(values['clear-files']
-			? { files: [] }
-			: values.file !== undefined
-				? { files: normalizeMutationPaths(repository, values.file) }
-				: {}),
-		...(values['clear-owner']
-			? { owner: null }
-			: values.owner !== undefined
-				? { owner: values.owner }
-				: {}),
-		...(values['clear-assignees']
-			? { assignees: [] }
-			: values.assignee !== undefined
-				? { assignees: values.assignee }
-				: {}),
-		...(values['clear-reviewers']
-			? { reviewers: [] }
-			: values.reviewer !== undefined
-				? { reviewers: values.reviewer }
-				: {}),
-		...(values['clear-team']
-			? { team: null }
-			: values.team !== undefined
-				? { team: values.team }
-				: {}),
-		...(values['clear-estimate']
-			? { estimate: null }
-			: values.estimate !== undefined
-				? { estimate: values.estimate }
-				: {}),
-		...(values['clear-effort']
-			? { effort: null }
-			: values.effort !== undefined
-				? { effort: values.effort }
-				: {}),
-		...(values['clear-risk']
-			? { risk: null }
-			: values.risk !== undefined
-				? { risk: values.risk }
-				: {}),
-		...(values['clear-due-date']
-			? { dueDate: null }
-			: values['due-date'] !== undefined
-				? { dueDate: values['due-date'] }
-				: {}),
-		...(values['clear-related']
-			? { related: [] }
-			: values.related !== undefined
-				? { related: values.related }
-				: {}),
-		...(values['clear-duplicates']
-			? { duplicates: [] }
-			: values.duplicate !== undefined
-				? { duplicates: values.duplicate }
-				: {}),
-		...(values['clear-parent']
-			? { parent: null }
-			: values.parent !== undefined
-				? { parent: values.parent }
-				: {}),
-		...(values['clear-directories']
-			? { directories: [] }
-			: values.directory !== undefined
-				? { directories: normalizeMutationPaths(repository, values.directory) }
-				: {}),
-		...(values['clear-projects']
-			? { projects: [] }
-			: values.project !== undefined
-				? { projects: values.project }
-				: {}),
-		...(values.body !== undefined ? { body: values.body } : {}),
+	const input: Record<string, unknown> = {}
+	if (values.title !== undefined) input.title = values.title
+	if (values.status !== undefined) input.status = values.status
+	if (values['clear-priority']) input.priority = null
+	else if (values.priority !== undefined) input.priority = values.priority
+	if (values['clear-order']) input.order = null
+	else if (values.order !== undefined) input.order = values.order
+	if (values['clear-labels']) input.labels = []
+	else if (values.label !== undefined) input.labels = values.label
+	if (values['clear-dependencies']) input.dependsOn = []
+	else if (values['depends-on'] !== undefined) input.dependsOn = values['depends-on']
+	if (values['clear-files']) input.files = []
+	else if (values.file !== undefined) input.files = normalizeMutationPaths(repository, values.file)
+	if (values['clear-owner']) input.owner = null
+	else if (values.owner !== undefined) input.owner = values.owner
+	if (values['clear-assignees']) input.assignees = []
+	else if (values.assignee !== undefined) input.assignees = values.assignee
+	if (values['clear-reviewers']) input.reviewers = []
+	else if (values.reviewer !== undefined) input.reviewers = values.reviewer
+	if (values['clear-team']) input.team = null
+	else if (values.team !== undefined) input.team = values.team
+	if (values['clear-estimate']) input.estimate = null
+	else if (values.estimate !== undefined) input.estimate = values.estimate
+	if (values['clear-effort']) input.effort = null
+	else if (values.effort !== undefined) input.effort = values.effort
+	if (values['clear-risk']) input.risk = null
+	else if (values.risk !== undefined) input.risk = values.risk
+	if (values['clear-due-date']) input.dueDate = null
+	else if (values['due-date'] !== undefined) input.dueDate = values['due-date']
+	if (values['clear-related']) input.related = []
+	else if (values.related !== undefined) input.related = values.related
+	if (values['clear-duplicates']) input.duplicates = []
+	else if (values.duplicate !== undefined) input.duplicates = values.duplicate
+	if (values['clear-parent']) input.parent = null
+	else if (values.parent !== undefined) input.parent = values.parent
+	if (values['clear-directories']) input.directories = []
+	else if (values.directory !== undefined) {
+		input.directories = normalizeMutationPaths(repository, values.directory)
 	}
+	if (values['clear-projects']) input.projects = []
+	else if (values.project !== undefined) input.projects = values.project
+	if (values['clear-severity']) input.severity = null
+	else if (values.severity !== undefined) input.severity = values.severity
+	if (values['clear-related-skills']) input.relatedSkills = []
+	else if (values['related-skill'] !== undefined) input.relatedSkills = values['related-skill']
+	if (values['clear-packs']) input.packs = []
+	else if (values.pack !== undefined) input.packs = values.pack
+	if (values['clear-class']) input.class = null
+	else if (values.class !== undefined) input.class = values.class
+	if (values['clear-cadence']) input.cadence = null
+	else if (values.cadence !== undefined) input.cadence = values.cadence
+	if (values.body !== undefined) input.body = values.body
+	return input as UpdateDocumentInput
 }
 
 export async function runCli(args: readonly string[], context: CliContext = {}): Promise<number> {
@@ -926,7 +935,9 @@ export async function runCli(args: readonly string[], context: CliContext = {}):
 			if (values.json) {
 				stdout(`${JSON.stringify(result, null, 2)}\n`)
 			} else if (result.valid) {
-				stdout(`Taskset repository is valid (${result.taskCount} tasks)\n`)
+				stdout(
+					`Taskset repository is valid (${result.taskCount} tasks, ${result.documentCount} documents)\n`,
+				)
 			} else {
 				for (const diagnostic of result.diagnostics) {
 					stdout(
@@ -1101,7 +1112,7 @@ export async function runCli(args: readonly string[], context: CliContext = {}):
 				const parsed = parseArgs({
 					args: subcommandArgs,
 					allowPositionals: true,
-					options: { ...metadataOptionDefinitions, ...commonOptionDefinitions },
+					options: { ...documentMetadataOptionDefinitions, ...commonOptionDefinitions },
 				})
 				const [rawType] = requirePositionals(parsed.positionals, 1, 'exactly one document type')
 				const values = parseSchema(
@@ -1136,6 +1147,11 @@ export async function runCli(args: readonly string[], context: CliContext = {}):
 							? { directories: normalizeMutationPaths(repository, values.directory) }
 							: {}),
 						...(values.project ? { projects: values.project } : {}),
+						...(values.severity ? { severity: values.severity } : {}),
+						...(values['related-skill'] ? { relatedSkills: values['related-skill'] } : {}),
+						...(values.pack ? { packs: values.pack } : {}),
+						...(values.class ? { class: values.class } : {}),
+						...(values.cadence ? { cadence: values.cadence } : {}),
 						...(values.body !== undefined ? { body: values.body } : {}),
 					},
 					{ onWarning },
@@ -1197,6 +1213,8 @@ export async function runCli(args: readonly string[], context: CliContext = {}):
 						team: { type: 'string', multiple: true },
 						risk: { type: 'string', multiple: true },
 						project: { type: 'string', multiple: true },
+						class: { type: 'string', multiple: true },
+						severity: { type: 'string', multiple: true },
 						'depends-on': { type: 'string' },
 						related: { type: 'string' },
 						duplicate: { type: 'string' },
@@ -1239,6 +1257,8 @@ export async function runCli(args: readonly string[], context: CliContext = {}):
 						...(values.team ? { teams: values.team } : {}),
 						...(values.risk ? { risks: values.risk } : {}),
 						...(values.project ? { projects: values.project } : {}),
+						...(values.class ? { classes: values.class } : {}),
+						...(values.severity ? { severities: values.severity } : {}),
 						...(values['depends-on'] ? { dependsOn: values['depends-on'] } : {}),
 						...(values.related ? { related: values.related } : {}),
 						...(values.duplicate ? { duplicate: values.duplicate } : {}),
@@ -1354,13 +1374,13 @@ export async function runCli(args: readonly string[], context: CliContext = {}):
 
 			if (subcommand === 'update') {
 				const clearDefinitions = Object.fromEntries(
-					UPDATE_CLEAR_PAIRS.map(([, clear]) => [clear, { type: 'boolean' as const }]),
+					DOCUMENT_UPDATE_CLEAR_PAIRS.map(([, clear]) => [clear, { type: 'boolean' as const }]),
 				)
 				const parsed = parseArgs({
 					args: subcommandArgs,
 					allowPositionals: true,
 					options: {
-						...metadataOptionDefinitions,
+						...documentMetadataOptionDefinitions,
 						...clearDefinitions,
 						...commonOptionDefinitions,
 						type: { type: 'string' },
@@ -1482,6 +1502,29 @@ export async function runCli(args: readonly string[], context: CliContext = {}):
 			return 0
 		}
 
+		if (subcommand === 'program') {
+			const parsed = parseArgs({
+				args: subcommandArgs,
+				allowPositionals: true,
+				options: commonOptionDefinitions,
+			})
+			const [parentId] = requirePositionals(parsed.positionals, 1, 'exactly one parent task ID')
+			const values = parseSchema(CommonValuesSchema, parsed.values, 'task program options')
+			const repository = await discoverRepository(resolveCommandCwd(cwd, values.cwd))
+			const rollup = await getProgramRollup(
+				repository,
+				parseSchema(TaskIdSchema, parentId, 'parent task ID'),
+			)
+			if (values.json) {
+				stdout(`${JSON.stringify(rollup, null, 2)}\n`)
+			} else {
+				stdout(
+					`${rollup.parentId}\t${rollup.status}\tchildren=${rollup.children.total}\topen=${rollup.children.openIds.length}\tconcerns=${rollup.relatedOpenConcerns.length}\tcloseoutReady=${rollup.closeoutReady}\t${rollup.title}\n`,
+				)
+			}
+			return 0
+		}
+
 		if (subcommand === 'create') {
 			const parsed = parseArgs({
 				args: subcommandArgs,