@ddtcorex/dsh-maestro-review 0.11.1 → 0.12.0

package/src/host/plan-track-tool.ts

@@ -1,118 +0,0 @@
-import { join, resolve, sep } from 'node:path'
-import { readFile, writeFile, mkdir, realpath } from 'node:fs/promises'
-import type { Context } from '@deepseek-ai/cordis'
-import { defineTool } from '@deepseek-ai/dsh-tools'
-import z from '@deepseek-ai/schemastery'
-
-export const name='maestro-plan-track-tool'
-export const inject=['tools']
-export const Config:z<{rootPath?:string}> = z.object({rootPath:z.string()})
-interface SC{agent?:{session?:{header?:{cwd?:string}}}}
-function workspaceRootFor(c:string|undefined,e:unknown):string{ if(c!==undefined) return c; const cwd=(e as SC|undefined)?.agent?.session?.header?.cwd; return typeof cwd==='string'&&cwd!==''?cwd:process.cwd()}
-async function isInsideRoot(r:string,t:string):Promise<boolean>{
-  const ar=resolve(r); const rs=resolve(ar,t)
-  if(rs!==ar && !rs.startsWith(ar+sep)) return false
-  try{ const rr=await realpath(ar); const rt=await realpath(rs); return rt===rr||rt.startsWith(rr+sep)}catch{
-    try{ const rr=await realpath(ar); const parent=resolve(rs,'..'); const rp=await realpath(parent); return rp===rr||rp.startsWith(rr+sep)}catch{ return rs===ar || rs.startsWith(ar+sep) }
-  }
-}
-
-type Task={id:string, title:string, status:'pending'|'in_progress'|'done'|'blocked', line:number}
-function parseTasks(md:string):Task[]{
-  const lines=md.split('\n')
-  const tasks:Task[]=[]
-  for(let i=0;i<lines.length;i++){
-    const m=/^###\s+(Task\s*\d+):?\s*(.*)/.exec(lines[i].trim())
-    if(!m) continue
-    const id=m[1].trim()
-    let title=m[2].trim()
-    let status:Task['status']='pending'
-    if(title.includes('in_progress')) status='in_progress'
-    else if(title.toLowerCase().includes('done') || title.includes('✅')) status='done'
-    else if(title.toLowerCase().includes('blocked')) status='blocked'
-    for(let j=i+1;j<Math.min(i+4, lines.length);j++){
-      if(lines[j].toLowerCase().includes('in_progress')) status='in_progress'
-      if(lines[j].toLowerCase().includes('status: done')) status='done'
-    }
-    tasks.push({id, title, status, line:i})
-  }
-  return tasks
-}
-
-export function apply(ctx:Context, config:{rootPath?:string}={}):void{
-  const configuredRoot=config.rootPath
-  ctx.effect(()=>ctx.tools.register(defineTool({
-    name:'maestro_plan_track',
-    description:'Track cross-repo plan: init/update/complete tasks with dtodo sync and oneTaskOneCommit guard.',
-    parameters:{
-      op:{type:'string', enum:['init','update','complete'], required:true},
-      planPath:{type:'string', required:true},
-      taskId:{type:'string'},
-      status:{type:'string', enum:['pending','in_progress','done','blocked']},
-      note:{type:'string'},
-    },
-    output:{
-      schema:{
-        type:'object', additionalProperties:true,
-        properties:{
-          ok:{type:'boolean', required:true},
-          plan:{type:'object', required:true, additionalProperties:true},
-          discipline:{type:'object', additionalProperties:true},
-        }
-      },
-      render:(_a,v:{ok:boolean})=>[{type:'text', text: v.ok? 'ok' : 'violation'}],
-    },
-    async execute(args, exec){
-      const op=(args as {op:string}).op
-      const rawPath=(args as {planPath:string}).planPath
-      const root=workspaceRootFor(configuredRoot, exec)
-      if(!(await isInsideRoot(root, rawPath))) return {text:`Path "${rawPath}" escapes the workspace root.`, truncated:false} as never
-      const planPath=resolve(root, rawPath)
-      let md=''
-      try{ md=await readFile(planPath,'utf-8') }catch{
-        if(op==='init') return {text:`plan not found ${rawPath}`, truncated:false} as never
-        md=''
-      }
-      const tasks=parseTasks(md)
-      const lines=md.split('\n')
-
-      if(op==='init'){
-        const nextTask=tasks.find(t=>t.status==='pending' || t.status==='in_progress') || tasks[0] || null
-        const dtodoPayload=tasks.map(t=>({content:`${t.id}: ${t.title}`, status: t.status}))
-        return {ok:true, plan:{path: rawPath, tasks, nextTask, dtodoPayload}, discipline:{violation:null}} as never
-      }
-      if(op==='update'){
-        const taskId=(args as {taskId?:string}).taskId
-        const status=(args as {status?:string}).status as Task['status'] | undefined
-        if(!taskId) return {text:'taskId required', truncated:false} as never
-        const idx=tasks.findIndex(t=>t.id===taskId)
-        if(idx<0) return {text:`task ${taskId} not found`, truncated:false} as never
-        if(status==='in_progress'){
-          const other=tasks.find(t=>t.id!==taskId && t.status==='in_progress')
-          if(other){
-            return {ok:false, plan:{path: rawPath, tasks, nextTask: tasks.find(t=>t.status==='in_progress')||null, dtodoPayload:[]}, discipline:{violation:'oneTaskOneCommit: only one task may be in_progress at a time'}} as never
-          }
-        }
-        const lineIdx=tasks[idx].line
-        if(status){
-          const orig=lines[lineIdx]
-          if(orig.includes('—')) lines[lineIdx]=orig.replace(/—.*$/, `— ${status}`)
-          else lines[lineIdx]=`${orig} — ${status}`
-          await mkdir(join(planPath,'..'),{recursive:true})
-          await writeFile(planPath, lines.join('\n'), 'utf-8')
-          tasks[idx].status=status
-        }
-        const nextTask=tasks.find(t=>t.status==='in_progress') || tasks.find(t=>t.status==='pending') || null
-        return {ok:true, plan:{path: rawPath, tasks, nextTask, dtodoPayload: tasks.map(t=>({content:`${t.id}: ${t.title}`, status:t.status}))}, discipline:{violation:null}} as never
-      }
-      if(op==='complete'){
-        const pending=tasks.filter(t=>t.status!=='done')
-        if(pending.length>0){
-          return {ok:false, plan:{path: rawPath, tasks, nextTask: pending[0], dtodoPayload:[]}, discipline:{violation:`pending tasks remain: ${pending.map(p=>p.id).join(',')}`}} as never
-        }
-        return {ok:true, plan:{path: rawPath, tasks, nextTask:null, dtodoPayload:[]}, discipline:{violation:null}} as never
-      }
-      return {text:`unknown op ${op}`, truncated:false} as never
-    }
-  }), 'plan track'))
-}

package/src/host/providers/github.stub.ts

@@ -1,11 +0,0 @@
-import type { ReviewProvider, ReviewRequest } from './interface.js'
-
-export const githubProvider: ReviewProvider = {
-  id: 'github',
-  async intake(_req: Request): Promise<ReviewRequest> {
-    throw new Error('github not implemented')
-  },
-  async postFindings(_findings: any[]): Promise<void> {
-    throw new Error('not implemented')
-  },
-}

package/src/host/providers/interface.ts

@@ -1,2 +0,0 @@
-export interface ReviewRequest { provider: string; projectPath: string; mrId: string; profile: 'magento2'|'generic'|'laravel'|'custom'; }
-export interface ReviewProvider { id: string; intake(req: Request): Promise<ReviewRequest>; postFindings(f: any[]): Promise<void>; }

package/src/host/tdd-evidence-tool.ts

@@ -1,85 +0,0 @@
-import { resolve, sep } from 'node:path'
-import { readFile, stat, realpath } from 'node:fs/promises'
-import { execFile } from 'node:child_process'
-import { promisify } from 'node:util'
-import type { Context } from '@deepseek-ai/cordis'
-import { defineTool } from '@deepseek-ai/dsh-tools'
-import z from '@deepseek-ai/schemastery'
-
-export const name='maestro-tdd-evidence-tool'
-export const inject=['tools']
-export const Config:z<{rootPath?:string}> = z.object({rootPath:z.string()})
-interface SC{agent?:{session?:{header?:{cwd?:string}}}}
-function workspaceRootFor(c:string|undefined,e:unknown):string{ if(c!==undefined) return c; const cwd=(e as SC|undefined)?.agent?.session?.header?.cwd; return typeof cwd==='string'&&cwd!==''?cwd:process.cwd()}
-async function isInsideRoot(r:string,t:string):Promise<boolean>{
-  const ar=resolve(r); const rs=resolve(ar,t)
-  if(rs!==ar && !rs.startsWith(ar+sep)) return false
-  try{ const rr=await realpath(ar); const rt=await realpath(rs); return rt===rr||rt.startsWith(rr+sep)}catch{
-    try{ const rr=await realpath(ar); const parent=resolve(rs,'..'); const rp=await realpath(parent); return rp===rr||rp.startsWith(rr+sep)}catch{ return rs===ar || rs.startsWith(ar+sep) }
-  }
-}
-const execFileAsync=promisify(execFile)
-
-export function apply(ctx:Context, config:{rootPath?:string}={}):void{
-  const configuredRoot=config.rootPath
-  // simple in-memory red evidence store per process
-  const redEvidence=new Set<string>()
-  ctx.effect(()=>ctx.tools.register(defineTool({
-    name:'maestro_tdd_evidence',
-    description:'Capture TDD evidence: red (failing test), green (passing), verify (pnpm verify). Enforces red-before-green.',
-    parameters:{
-      op:{type:'string', enum:['red','green','verify'], required:true},
-      testFile:{type:'string'},
-      evidence:{type:'string'},
-    },
-    output:{
-      schema:{
-        type:'object', additionalProperties:true,
-        properties:{
-          ok:{type:'boolean', required:true},
-          phase:{type:'string'},
-          error:{type:'string'},
-          verify:{type:'object', additionalProperties:true},
-        }
-      },
-      render:(_a,v:{ok:boolean, error?:string})=>[{type:'text', text: v.ok? 'ok' : (v.error ?? 'error')}],
-    },
-    async execute(args, exec){
-      const op=(args as {op:string}).op
-      const rawTest=(args as {testFile?:string}).testFile
-      const root=workspaceRootFor(configuredRoot, exec)
-      if(rawTest && !(await isInsideRoot(root, rawTest))) return {text:`Path "${rawTest}" escapes the workspace root.`, truncated:false} as never
-      if(op==='red'){
-        if(!rawTest) return {text:'testFile required for red', truncated:false} as never
-        const abs=resolve(root, rawTest)
-        try{ const s=await stat(abs); if(!s.isFile()) return {ok:false, phase:'red', error:'test file not found'} as never }catch{ return {ok:false, phase:'red', error:'test file not found'} as never }
-        const content=await readFile(abs,'utf-8').catch(()=>'')
-        // red evidence is that file contains failing expectation (throw, expect fail, etc.)
-        redEvidence.add(rawTest)
-        return {ok:true, phase:'red', testFile: rawTest, evidence: content.slice(0,500), redEvidenceSize: redEvidence.size} as never
-      }
-      if(op==='green'){
-        if(!rawTest) return {text:'testFile required for green', truncated:false} as never
-        if(!redEvidence.has(rawTest)){
-          // also check file exists? If not in redEvidence, error must contain 'red'
-          return {ok:false, phase:'green', error:'red evidence required before green — run op:red first'} as never
-        }
-        const abs=resolve(root, rawTest)
-        try{ await stat(abs) }catch{ return {ok:false, phase:'green', error:'test file not found'} as never }
-        return {ok:true, phase:'green', testFile: rawTest} as never
-      }
-      if(op==='verify'){
-        // try to run pnpm verify -- if not available, return ok false but with verify object
-        try{
-          const {stdout}=await execFileAsync('pnpm', ['verify'], {cwd:root, timeout:30000}) as any
-          return {ok:true, phase:'verify', verify:{passed:true, output: String(stdout).slice(0,2000)}} as never
-        }catch(e:any){
-          const out=(e.stdout ?? '') + (e.stderr ?? '') + String(e.message)
-          const passed=out.includes('Tests') && !out.includes('FAIL')
-          return {ok:passed, phase:'verify', verify:{passed, output: out.slice(0,2000)}, error: passed? undefined : 'verify failed'} as never
-        }
-      }
-      return {text:`unknown op ${op}`, truncated:false} as never
-    }
-  }), 'tdd evidence'))
-}

package/src/host/webhook-secret.ts

@@ -1,43 +0,0 @@
-/**
- * Webhook secret generation and the URL an operator pastes into GitLab.
- *
- * Parked at the meta root when the Maestro settings card lost its GitLab tab,
- * and never ported: `review` kept the secret FIELD in its own settings section
- * but had no way to produce a value for it, so the operator had to invent a
- * 32-character base64url string by hand. A pasted secret with a `+`, a `/` or
- * a `=` is a common outcome, and those characters are exactly what GitLab's
- * token comparison and a URL path segment cannot carry.
- */
-
-const BASE64URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
-
-/** The merge-request webhook path this plugin serves. */
-export const GITLAB_WEBHOOK_PATH = '/hooks/gitlab-mr'
-
-/**
- * Generate an opaque 256-bit secret suitable for GitLab's webhook token.
- *
- * Each byte contributes 6 bits (`byte & 0b00111111`), so the result is always
- * 32 base64url characters with no padding and no character outside the
- * alphabet — the two properties GitLab's comparison and a URL path segment
- * both need. The randomness source is injectable so the mapping is testable
- * without weakening the production path.
- */
-export function generateWebhookSecret(
-  randomValues: (array: Uint8Array) => Uint8Array = globalThis.crypto.getRandomValues.bind(globalThis.crypto),
-): string {
-  const bytes = randomValues(new Uint8Array(32))
-  return Array.from(bytes, byte => BASE64URL_ALPHABET[byte & 0b00111111]).join('')
-}
-
-/**
- * GitLab's merge-request webhook endpoint for the configured public hostname.
- *
- * A user pasting the value back out of the settings field usually brings a
- * scheme and a trailing slash with it, so both are stripped. An absent
- * hostname names itself rather than producing a URL that looks real.
- */
-export function gitlabWebhookUrl(hostname?: string): string {
-  const authority = hostname?.trim().replace(/^https?:\/\//, '').replace(/\/+$/, '') || '<your-hostname>'
-  return `https://${authority}${GITLAB_WEBHOOK_PATH}`
-}