@4-r-c-4-n-4/todo 0.1.2

package/dist/commands/new.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNew = registerNew;
+const node_fs_1 = require("node:fs");
+const config_js_1 = require("../config.js");
+const context_js_1 = require("../context.js");
+const fingerprint_js_1 = require("../fingerprint.js");
+const ticket_js_1 = require("../ticket.js");
+const VALID_TYPES = [
+    "bug",
+    "feature",
+    "refactor",
+    "chore",
+    "debt",
+];
+const VALID_SOURCES = [
+    "log",
+    "test",
+    "agent",
+    "human",
+    "comment",
+];
+function registerNew(program) {
+    program
+        .command("new [summary]")
+        .description("Create a new ticket")
+        .option("-t, --type <type>", "ticket type: bug|feature|refactor|chore|debt", "chore")
+        .option("-s, --source <source>", "source type: log|test|agent|human|comment", "human")
+        .option("-f, --file <path>", "associate a file path")
+        .option("-l, --lines <start,end>", "line range for the file (e.g. 10,20)")
+        .option("--tags <tags>", "comma-separated tags")
+        .option("--parent <id>", "parent ticket ID")
+        .option("--pipe", "read summary from stdin")
+        .action((summaryArg, opts) => {
+        // Validate type
+        const ticketType = opts.type;
+        if (!VALID_TYPES.includes(ticketType)) {
+            console.error(`Error: invalid type '${ticketType}'. Must be one of: ${VALID_TYPES.join(", ")}`);
+            process.exit(1);
+        }
+        // Validate source
+        const sourceType = opts.source;
+        if (!VALID_SOURCES.includes(sourceType)) {
+            console.error(`Error: invalid source '${sourceType}'. Must be one of: ${VALID_SOURCES.join(", ")}`);
+            process.exit(1);
+        }
+        // Get context (init required)
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot } = ctx;
+        // Ensure dirs exist
+        (0, config_js_1.ensureTodoDir)(repoRoot);
+        // Handle --pipe
+        let summary;
+        if (opts.pipe) {
+            if (process.stdin.isTTY) {
+                console.error("Error: --pipe requires piped input");
+                process.exit(1);
+            }
+            const stdinContent = (0, node_fs_1.readFileSync)("/dev/stdin", "utf8");
+            const lines = stdinContent.split("\n").filter((l) => l.trim() !== "");
+            summary = lines[lines.length - 1] ?? "";
+        }
+        else {
+            summary = summaryArg ?? "";
+        }
+        if (!summary.trim()) {
+            console.error("Error: summary is required");
+            process.exit(1);
+        }
+        // Build source object
+        const sourceObj = { type: sourceType };
+        // Compute traceback fingerprint for log/test sources with piped content
+        if (opts.pipe && (sourceType === "log" || sourceType === "test")) {
+            // summary was extracted from stdin; we want to fingerprint the full content
+            // re-read isn't possible; fingerprint from summary as best-effort
+            const fp = (0, fingerprint_js_1.tracebackFingerprint)(summary);
+            sourceObj["traceback_fingerprint"] = fp;
+        }
+        // Build file reference
+        let fileRefs;
+        if (opts.file) {
+            const fileRef = { path: opts.file };
+            if (opts.lines) {
+                const parts = opts.lines.split(",");
+                if (parts.length === 2) {
+                    const start = parseInt(parts[0], 10);
+                    const end = parseInt(parts[1], 10);
+                    if (!isNaN(start) && !isNaN(end)) {
+                        fileRef.lines = [start, end];
+                    }
+                }
+            }
+            fileRefs = [fileRef];
+        }
+        // Parse tags
+        let tags;
+        if (opts.tags) {
+            tags = opts.tags
+                .split(",")
+                .map((t) => t.trim())
+                .filter((t) => t.length > 0);
+        }
+        const createdAt = new Date().toISOString();
+        const rawPayload = summary + (opts.file ?? "");
+        const id = (0, ticket_js_1.generateId)(sourceType, rawPayload, createdAt);
+        // Dedup check
+        try {
+            const openTickets = (0, ticket_js_1.listTickets)(repoRoot, "open");
+            for (const existing of openTickets) {
+                if (existing.summary === summary) {
+                    console.error(`Warning: possible duplicate of ${existing.id}`);
+                    break;
+                }
+            }
+        }
+        catch {
+            // ignore listing errors
+        }
+        // Handle parent
+        if (opts.parent) {
+            const { readTicketByPrefix } = require("../ticket.js");
+            try {
+                const parentTicket = readTicketByPrefix(repoRoot, opts.parent);
+                if (!parentTicket.relationships)
+                    parentTicket.relationships = {};
+                if (!parentTicket.relationships.children)
+                    parentTicket.relationships.children = [];
+                parentTicket.relationships.children.push(id);
+                parentTicket.updated_at = createdAt;
+                (0, ticket_js_1.writeTicket)(repoRoot, parentTicket);
+            }
+            catch {
+                console.error(`Error: parent ticket '${opts.parent}' not found`);
+                process.exit(1);
+            }
+        }
+        // Build ticket
+        const ticket = {
+            id,
+            type: ticketType,
+            state: "open",
+            summary,
+            source: sourceObj,
+            created_at: createdAt,
+            updated_at: createdAt,
+        };
+        if (fileRefs)
+            ticket.files = fileRefs;
+        if (tags && tags.length > 0)
+            ticket.tags = tags;
+        if (opts.parent) {
+            ticket.relationships = { parent: opts.parent };
+        }
+        (0, ticket_js_1.writeTicket)(repoRoot, ticket);
+        console.log(ticket.id);
+    });
+}

package/dist/commands/scan.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerScan(program: Command): void;

package/dist/commands/scan.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScan = registerScan;
+const node_crypto_1 = require("node:crypto");
+const config_js_1 = require("../config.js");
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const git_js_1 = require("../git.js");
+const scan_js_1 = require("../scan.js");
+const ticket_js_1 = require("../ticket.js");
+const VALID_TYPES = [
+    "bug",
+    "feature",
+    "refactor",
+    "chore",
+    "debt",
+];
+function registerScan(program) {
+    program
+        .command("scan")
+        .description("Scan source tree for TODO/FIXME/etc comments and create tickets")
+        .option("--dry-run", "print what would be created, do not write")
+        .option("--type <type>", "ticket type for created tickets", "chore")
+        .action((opts) => {
+        try {
+            const ticketType = opts.type;
+            if (!VALID_TYPES.includes(ticketType)) {
+                console.error(`Error: invalid type '${ticketType}'. Must be one of: ${VALID_TYPES.join(", ")}`);
+                process.exit(1);
+            }
+            const ctx = (0, context_js_1.getContext)(true);
+            const { repoRoot, config } = ctx;
+            const scanPatterns = config.intake?.scan_patterns ?? [
+                "TODO",
+                "FIXME",
+                "HACK",
+                "XXX",
+            ];
+            const scanExclude = config.intake?.scan_exclude ?? [
+                ".todo",
+                "node_modules",
+                ".git",
+                "dist",
+                "build",
+            ];
+            (0, config_js_1.ensureTodoDir)(repoRoot);
+            const matches = (0, scan_js_1.scanComments)(repoRoot, scanPatterns, scanExclude);
+            // Load all open tickets for dedup
+            const openTickets = (0, ticket_js_1.listTickets)(repoRoot, "open");
+            let created = 0;
+            let skipped = 0;
+            for (const match of matches) {
+                const normalizedText = match.text.trim().toLowerCase();
+                const fingerprint = (0, node_crypto_1.createHash)("sha256")
+                    .update(normalizedText)
+                    .digest("hex");
+                // Check for existing ticket with same fingerprint
+                const exists = openTickets.some((t) => {
+                    if (t.source.type === "comment" && t.source.raw) {
+                        const existingFp = (0, node_crypto_1.createHash)("sha256")
+                            .update(t.source.raw.trim().toLowerCase())
+                            .digest("hex");
+                        return existingFp === fingerprint;
+                    }
+                    return false;
+                });
+                if (exists) {
+                    console.log(`Skipping existing: ${match.text}`);
+                    skipped++;
+                    continue;
+                }
+                if (opts.dryRun) {
+                    console.log(`Would create: ${match.file}:${match.line} [${match.keyword}] ${match.text}`);
+                    created++;
+                    continue;
+                }
+                const createdAt = new Date().toISOString();
+                const id = (0, ticket_js_1.generateId)("comment", match.text + match.file + match.line, createdAt);
+                let lastCommit;
+                try {
+                    const c = (0, git_js_1.getLastCommitForFile)(match.file, repoRoot);
+                    if (c)
+                        lastCommit = c;
+                }
+                catch {
+                    lastCommit = undefined;
+                }
+                const ticket = {
+                    id,
+                    type: ticketType,
+                    state: "open",
+                    summary: `${match.keyword}: ${match.text}`.slice(0, 120),
+                    source: { type: "comment", raw: match.text },
+                    files: [
+                        {
+                            path: match.file,
+                            lines: [match.line, match.line],
+                            commit: lastCommit,
+                        },
+                    ],
+                    created_at: createdAt,
+                    updated_at: createdAt,
+                };
+                (0, ticket_js_1.writeTicket)(repoRoot, ticket);
+                openTickets.push(ticket); // add to in-memory list for subsequent dedup checks
+                created++;
+            }
+            console.log(`Created ${created} tickets, skipped ${skipped} duplicates`);
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/commands/show.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerShow(program: Command): void;

package/dist/commands/show.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerShow = registerShow;
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const ticket_js_1 = require("../ticket.js");
+function formatDate(iso) {
+    return iso.slice(0, 10); // YYYY-MM-DD
+}
+function formatTicketDetail(ticket) {
+    const lines = [];
+    lines.push(`=== ${ticket.id} [${ticket.type}] ${ticket.state} ===`);
+    lines.push(`SUMMARY: ${ticket.summary}`);
+    if (ticket.tags && ticket.tags.length > 0) {
+        lines.push(`TAGS: ${ticket.tags.join(", ")}`);
+    }
+    lines.push(`CREATED: ${ticket.created_at}`);
+    lines.push(`UPDATED: ${ticket.updated_at}`);
+    if (ticket.description) {
+        lines.push("");
+        lines.push(`DESCRIPTION: ${ticket.description}`);
+    }
+    // Source
+    lines.push("");
+    lines.push(`SOURCE: ${ticket.source.type}`);
+    if ("test_file" in ticket.source && ticket.source.test_file) {
+        const fn = "test_function" in ticket.source
+            ? ticket.source.test_function
+            : undefined;
+        lines.push(`  File: ${ticket.source.test_file}${fn ? `::${fn}` : ""}`);
+    }
+    if ("raw" in ticket.source && ticket.source.raw) {
+        lines.push(`  Raw: ${ticket.source.raw}`);
+    }
+    // Files
+    if (ticket.files && ticket.files.length > 0) {
+        lines.push("");
+        lines.push("FILES:");
+        for (const f of ticket.files) {
+            let desc = `  ${f.path}`;
+            if (f.lines)
+                desc += `:${f.lines[0]}-${f.lines[1]}`;
+            if (f.commit)
+                desc += ` (${f.commit.slice(0, 7)})`;
+            if (f.note)
+                desc += ` — ${f.note}`;
+            lines.push(desc);
+        }
+    }
+    // Analysis
+    if (ticket.analysis && ticket.analysis.length > 0) {
+        lines.push("");
+        lines.push(`ANALYSIS: (${ticket.analysis.length} entries)`);
+        for (let i = 0; i < ticket.analysis.length; i++) {
+            const a = ticket.analysis[i];
+            const conf = a.confidence ? ` [${a.confidence}]` : "";
+            lines.push(`  [${i}] ${formatDate(a.timestamp)} • ${a.type}${conf}`);
+            lines.push(`      ${a.content}`);
+        }
+    }
+    // Relationships
+    if (ticket.relationships) {
+        const rel = ticket.relationships;
+        const parts = [];
+        if (rel.parent)
+            parts.push(`  parent: ${rel.parent}`);
+        if (rel.children && rel.children.length > 0)
+            parts.push(`  children: ${rel.children.join(", ")}`);
+        if (rel.depends_on && rel.depends_on.length > 0)
+            parts.push(`  depends_on: ${rel.depends_on.join(", ")}`);
+        if (rel.blocks && rel.blocks.length > 0)
+            parts.push(`  blocks: ${rel.blocks.join(", ")}`);
+        if (rel.related && rel.related.length > 0)
+            parts.push(`  related: ${rel.related.join(", ")}`);
+        if (rel.duplicates)
+            parts.push(`  duplicates: ${rel.duplicates}`);
+        if (rel.linked_commits && rel.linked_commits.length > 0)
+            parts.push(`  linked_commits: ${rel.linked_commits.join(", ")}`);
+        if (parts.length > 0) {
+            lines.push("");
+            lines.push("RELATIONSHIPS:");
+            lines.push(...parts);
+        }
+    }
+    // Work
+    if (ticket.work) {
+        lines.push("");
+        lines.push("WORK:");
+        lines.push(`  branch: ${ticket.work.branch}`);
+        lines.push(`  base: ${ticket.work.base_branch}`);
+        lines.push(`  started: ${ticket.work.started_at} by ${ticket.work.started_by}`);
+    }
+    // Resolution
+    if (ticket.resolution) {
+        lines.push("");
+        lines.push("RESOLUTION:");
+        lines.push(`  commit: ${ticket.resolution.commit}`);
+        lines.push(`  resolved_at: ${ticket.resolution.resolved_at} by ${ticket.resolution.resolved_by}`);
+        if (ticket.resolution.test_file) {
+            const fn = ticket.resolution.test_function
+                ? `::${ticket.resolution.test_function}`
+                : "";
+            lines.push(`  test: ${ticket.resolution.test_file}${fn}`);
+        }
+        if (ticket.resolution.note) {
+            lines.push(`  note: ${ticket.resolution.note}`);
+        }
+    }
+    return lines.join("\n");
+}
+function registerShow(program) {
+    program
+        .command("show <id>")
+        .description("Show ticket details")
+        .option("--raw", "dump raw JSON")
+        .action((id, opts) => {
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot } = ctx;
+        try {
+            const ticket = (0, ticket_js_1.readTicketByPrefix)(repoRoot, id);
+            if (opts.raw) {
+                console.log(JSON.stringify(ticket, null, 2));
+            }
+            else {
+                console.log(formatTicketDetail(ticket));
+            }
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/commands/transition.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerTransition(program: Command): void;

package/dist/commands/transition.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTransition = registerTransition;
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const state_js_1 = require("../state.js");
+const ticket_js_1 = require("../ticket.js");
+const VALID_STATES = [
+    "open",
+    "active",
+    "blocked",
+    "done",
+    "wontfix",
+    "duplicate",
+];
+function registerTransition(program) {
+    program
+        .command("transition <id> <state>")
+        .description("Transition ticket state")
+        .option("--commit <sha>", "resolution commit")
+        .option("--test <file::func>", "test file and function (colon-separated)")
+        .option("--note <text>", "resolution note")
+        .option("--depends-on <id>", "set dependency")
+        .option("--duplicate-of <id>", "mark as duplicate")
+        .action((id, state, opts) => {
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot } = ctx;
+        if (!VALID_STATES.includes(state)) {
+            console.error(`Error: invalid state '${state}'. Must be one of: ${VALID_STATES.join(", ")}`);
+            process.exit(1);
+        }
+        try {
+            const ticket = (0, ticket_js_1.readTicketByPrefix)(repoRoot, id);
+            const fromState = ticket.state;
+            // Parse --test as "file::func" or "file"
+            let testFile;
+            let testFunction;
+            if (opts.test) {
+                const parts = opts.test.split("::");
+                testFile = parts[0];
+                testFunction = parts[1];
+            }
+            const params = {
+                commit: opts.commit,
+                test_file: testFile,
+                test_function: testFunction,
+                note: opts.note,
+                depends_on: opts.dependsOn,
+                duplicate_of: opts.duplicateOf,
+            };
+            try {
+                (0, state_js_1.validateTransition)(ticket, state, params, repoRoot);
+            }
+            catch (err) {
+                console.error(`Error: ${err.message}`);
+                process.exit(1);
+            }
+            const updated = (0, state_js_1.applyTransition)(ticket, state, params, repoRoot);
+            (0, ticket_js_1.writeTicket)(repoRoot, updated);
+            console.log(`Transitioned ${updated.id}: ${fromState} → ${state}`);
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/commands/work.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerWork(program: Command): void;

package/dist/commands/work.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWork = registerWork;
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const git_js_1 = require("../git.js");
+const state_js_1 = require("../state.js");
+const ticket_js_1 = require("../ticket.js");
+function registerWork(program) {
+    program
+        .command("work <id>")
+        .description("Start or resume work on a ticket")
+        .option("--branch <name>", "override branch name")
+        .option("--actor <name>", "override actor (also reads TODO_ACTOR env)")
+        .action((id, opts) => {
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot } = ctx;
+        try {
+            const ticket = (0, ticket_js_1.readTicketByPrefix)(repoRoot, id);
+            // Check not terminal
+            if (ticket_js_1.TERMINAL_STATES.includes(ticket.state)) {
+                console.error(`Error: ticket ${ticket.id} is in terminal state '${ticket.state}'. Cannot work on it.`);
+                process.exit(1);
+            }
+            // Resolve branch name
+            let branch;
+            if (opts.branch) {
+                branch = opts.branch;
+            }
+            else if (ticket.relationships?.parent) {
+                branch = `todo/${ticket.relationships.parent}`;
+            }
+            else {
+                branch = `todo/${ticket.id}`;
+            }
+            // Resolve actor
+            let actor;
+            if (opts.actor) {
+                actor = opts.actor;
+            }
+            else if (process.env["TODO_ACTOR"]) {
+                actor = process.env["TODO_ACTOR"];
+            }
+            else {
+                try {
+                    actor = (0, git_js_1.getGitUserName)(repoRoot);
+                }
+                catch {
+                    actor = "unknown";
+                }
+            }
+            const defaultBranch = (0, git_js_1.getDefaultBranch)(repoRoot);
+            if ((0, git_js_1.branchExists)(branch, repoRoot)) {
+                // Resume
+                (0, git_js_1.checkoutBranch)(branch, repoRoot);
+                // Ensure ticket is active
+                if (ticket.state !== "active") {
+                    const params = { actor };
+                    try {
+                        const updated = (0, state_js_1.applyTransition)(ticket, "active", params, repoRoot);
+                        (0, ticket_js_1.writeTicket)(repoRoot, updated);
+                    }
+                    catch {
+                        // if transition fails (e.g. already done), just proceed
+                    }
+                }
+                let ahead;
+                try {
+                    ahead = (0, git_js_1.getCommitsAhead)(branch, defaultBranch, repoRoot);
+                }
+                catch {
+                    ahead = 0;
+                }
+                console.log(`Resumed branch ${branch} — ticket ${ticket.id} is active. Branch has ${ahead} commits ahead of ${defaultBranch}.`);
+            }
+            else {
+                // New branch
+                const now = new Date().toISOString();
+                const params = {
+                    actor,
+                };
+                let updated;
+                try {
+                    updated = (0, state_js_1.applyTransition)(ticket, "active", params, repoRoot);
+                }
+                catch (err) {
+                    console.error(`Error: ${err.message}`);
+                    process.exit(1);
+                }
+                // Populate work block
+                updated.work = {
+                    branch,
+                    base_branch: defaultBranch,
+                    started_at: now,
+                    started_by: actor,
+                };
+                updated.updated_at = now;
+                (0, ticket_js_1.writeTicket)(repoRoot, updated);
+                (0, git_js_1.createBranch)(branch, repoRoot);
+                console.log(`Created branch ${branch} — ticket ${ticket.id} is now active.`);
+            }
+            // Check depends_on: warn if dep commit not ancestor of HEAD
+            const deps = ticket.relationships?.depends_on ?? [];
+            for (const depId of deps) {
+                try {
+                    const dep = (0, ticket_js_1.readTicket)(repoRoot, depId);
+                    if (dep.resolution?.commit) {
+                        const depCommit = dep.resolution.commit;
+                        try {
+                            if (!(0, git_js_1.isAncestor)(depCommit, "HEAD", repoRoot)) {
+                                console.error(`Warning: dependency ${depId} resolved at ${depCommit} is not an ancestor of HEAD`);
+                            }
+                        }
+                        catch {
+                            // ignore ancestor check failures
+                        }
+                    }
+                }
+                catch {
+                    // ignore dep lookup failures
+                }
+            }
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from "./types.js";
+export declare const DEFAULT_CONFIG: Config;
+export declare function loadConfig(repoRoot: string): Config;
+export declare function getTodoDir(repoRoot: string): string;
+export declare function ensureTodoDir(repoRoot: string): void;
+export declare function getIdLength(config: Config): number;
+export declare function getCommitPrefix(config: Config): string;