jackherd 0.0.1 → 1.0.1

package/src/vocabulary/index.ts

@@ -0,0 +1,132 @@
+export const PLAN_LANGUAGE = { de: 'de', en: 'en' } as const
+
+export type PlanLanguage = (typeof PLAN_LANGUAGE)[keyof typeof PLAN_LANGUAGE]
+
+/** The language's name as a reply or a question says it. */
+export const LANGUAGE_NAME: Record<PlanLanguage, string> = {
+  [PLAN_LANGUAGE.en]: 'English',
+  [PLAN_LANGUAGE.de]: 'German',
+}
+
+export const isPlanLanguage = (value: string): value is PlanLanguage =>
+  (Object.values(PLAN_LANGUAGE) as string[]).includes(value)
+
+export const PLAN_STATUS = {
+  done: 'done',
+  abandoned: 'abandoned',
+  inProgress: 'inProgress',
+  draft: 'draft',
+  other: 'other',
+  none: 'none',
+} as const
+
+export type PlanStatus = (typeof PLAN_STATUS)[keyof typeof PLAN_STATUS]
+
+export type StatusWord = {
+  label: string
+  /** Lower-case words a `Status:` line starts with; empty for `other` and `none`. */
+  leading: readonly string[]
+  /** Lower-case fragments that classify a `Status:` line wherever they appear. */
+  anywhere: readonly string[]
+}
+
+export type PlanVocabulary = {
+  header: { date: string; status: string; scope: string }
+  sections: {
+    decisions: string
+    implementation: string
+    modelRecommendations: string
+    dependencies: string
+    documentation: string
+    lanes: string
+    goal: string
+    history: string
+    plans: string
+  }
+  columns: { dependsOn: string; writes: string; serialMarker: string }
+  phase: string
+  /** Opens the line by which a phase says it has no review gate on purpose: `**Kein Review-Gate:** <reason>`. */
+  noReviewGate: string
+  /** Marks a lane as closed when its name cell contains it. */
+  laneClosed: string
+  /** Words that may stand between two phases of one entry (`P1 Rule und P2 Monitor`). */
+  phaseConnectors: readonly string[]
+  statusWords: Record<PlanStatus, StatusWord>
+}
+
+export const PLAN_VOCABULARY: Record<PlanLanguage, PlanVocabulary> = {
+  de: {
+    header: { date: 'Date', status: 'Status', scope: 'Scope' },
+    sections: {
+      decisions: 'Entscheidungen',
+      implementation: 'Umsetzung',
+      modelRecommendations: 'Model-Empfehlungen pro Phase',
+      dependencies: 'Abhängigkeiten und Parallelisierung',
+      documentation: 'Dokumentation',
+      lanes: 'Spuren',
+      goal: 'Sprintziel',
+      history: 'Verlauf',
+      plans: 'Pläne',
+    },
+    columns: { dependsOn: 'Hängt ab von', writes: 'Schreibt', serialMarker: 'Seriell-Marker' },
+    phase: 'Phase',
+    noReviewGate: 'Kein Review-Gate',
+    laneClosed: 'abgeräumt',
+    phaseConnectors: ['danach', 'und', 'dann', 'sowie'],
+    statusWords: {
+      done: { label: 'Done', leading: ['done'], anywhere: ['abgeschlossen'] },
+      abandoned: { label: 'Abandoned', leading: ['abandoned'], anywhere: ['verworfen'] },
+      inProgress: { label: 'In Arbeit', leading: ['in progress'], anywhere: ['umgesetzt', 'phase'] },
+      draft: { label: 'Draft', leading: ['draft'], anywhere: [] },
+      other: { label: 'Sonstiges', leading: [], anywhere: [] },
+      none: { label: 'Ohne Status', leading: [], anywhere: [] },
+    },
+  },
+  en: {
+    header: { date: 'Date', status: 'Status', scope: 'Scope' },
+    sections: {
+      decisions: 'Decisions',
+      implementation: 'Implementation',
+      modelRecommendations: 'Model recommendations per phase',
+      dependencies: 'Dependencies and parallelization',
+      documentation: 'Documentation',
+      lanes: 'Lanes',
+      goal: 'Sprint goal',
+      history: 'History',
+      plans: 'Plans',
+    },
+    columns: { dependsOn: 'Depends on', writes: 'Writes', serialMarker: 'Serial marker' },
+    phase: 'Phase',
+    noReviewGate: 'No review gate',
+    laneClosed: 'cleaned up',
+    phaseConnectors: ['then', 'and', 'after'],
+    statusWords: {
+      done: { label: 'Done', leading: ['done'], anywhere: ['completed'] },
+      abandoned: { label: 'Abandoned', leading: ['abandoned'], anywhere: ['dropped'] },
+      inProgress: { label: 'In progress', leading: ['in progress'], anywhere: ['implemented', 'phase'] },
+      draft: { label: 'Draft', leading: ['draft'], anywhere: [] },
+      other: { label: 'Other', leading: [], anywhere: [] },
+      none: { label: 'No status', leading: [], anywhere: [] },
+    },
+  },
+}
+
+const STATUS_PRECEDENCE = [PLAN_STATUS.done, PLAN_STATUS.abandoned, PLAN_STATUS.inProgress, PLAN_STATUS.draft] as const
+
+/** Classifies a free-text `Status:` line; the first matching status in precedence order wins. */
+export const classifyStatus = (language: PlanLanguage, statusText: string): PlanStatus => {
+  const { statusWords } = PLAN_VOCABULARY[language]
+  const lowerStatus = statusText.toLowerCase()
+  const matches = ({ leading, anywhere }: StatusWord) =>
+    leading.some((word) => lowerStatus.startsWith(word)) || anywhere.some((fragment) => lowerStatus.includes(fragment))
+  const matched = STATUS_PRECEDENCE.find((status) => matches(statusWords[status]))
+  if (matched) return matched
+  return statusText.trim() ? PLAN_STATUS.other : PLAN_STATUS.none
+}
+
+/** `### Phase 3: Title` as the plan spells it in `language`. */
+export const phaseHeading = (language: PlanLanguage, id: string, title: string): string =>
+  `### ${PLAN_VOCABULARY[language].phase} ${id}: ${title}`
+
+export const sectionHeading = (language: PlanLanguage, section: keyof PlanVocabulary['sections']): string =>
+  `## ${PLAN_VOCABULARY[language].sections[section]}`

package/src/watch/base-tip.ts

@@ -0,0 +1,18 @@
+const COMMIT = /^[0-9a-f]{40}$/
+
+/** The commit of `refs/heads/<branch>` in a `git ls-remote` answer; null when it is not listed. */
+export const remoteTipOf = (lsRemote: string, branch: string): string | null => {
+  const ref = `refs/heads/${branch}`
+  for (const line of lsRemote.split('\n')) {
+    const [commit, name] = line.trim().split(/\s+/)
+    if (name === ref && commit && COMMIT.test(commit)) return commit
+  }
+  return null
+}
+
+/**
+ * Whether the base branch has to be fetched: the remote moved past the local remote-tracking ref, or
+ * there is none yet. A remote that could not be read is no reason to fetch.
+ */
+export const baseFetchNeeded = (remoteTip: string | null, localTip: string | null): boolean =>
+  remoteTip !== null && remoteTip !== localTip